home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / varie / uae-0_64.lha / uae-0.6.4 / src / custom.c < prev    next >
C/C++ Source or Header  |  1996-09-10  |  84KB  |  3,055 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * Custom chip emulation
  5.   * 
  6.   * (c) 1995 Bernd Schmidt, Alessandro Bissacco
  7.   */
  8.  
  9. #include "sysconfig.h"
  10. #include "sysdeps.h"
  11.  
  12. #include <ctype.h>
  13. #include <assert.h>
  14.  
  15. #include "config.h"
  16. #include "options.h"
  17. #include "events.h"
  18. #include "memory.h"
  19. #include "custom.h"
  20. #include "newcpu.h"
  21. #include "cia.h"
  22. #include "disk.h"
  23. #include "blitter.h"
  24. #include "xwin.h"
  25. #include "os.h"
  26. #include "keybuf.h"
  27. #include "serial.h"
  28.  
  29. /* #define EMULATE_AGA */
  30.  
  31. #ifndef EMULATE_AGA
  32. #define AGA_CHIPSET 0
  33. #else
  34. #define AGA_CHIPSET 1
  35. #endif
  36.  
  37. #define SMART_UPDATE 1
  38.  
  39. #define MAX_PLANES 8
  40.  
  41. #define PIXEL_XPOS(HPOS) (((HPOS)*2 - 0x30)*(use_lores ? 1 : 2))
  42.  
  43. /* These are default values for mouse calibration.
  44.  * The first two are default values for mstepx and mstepy.
  45.  * The second line set the orizontal and vertical offset for amiga and X 
  46.  * pointer matching
  47.  */
  48.    
  49. #define defstepx (1<<16)
  50. #define defstepy (1<<16)
  51. #define defxoffs 0
  52. #define defyoffs 0
  53.     
  54. /* Values below define mouse auto calibration process.
  55.  * They are not critical, change them if you want.
  56.  * The most important is calweight, which sets mouse adjustement rate */ 
  57.  
  58. static const int docal = 60, xcaloff = 40, ycaloff = 20;
  59. static const int calweight = 3;
  60. static int lastsampledmx, lastsampledmy;
  61.  
  62.  /*
  63.   * Events
  64.   */
  65.  
  66. unsigned long int cycles, nextevent;
  67. int vpos;
  68. UWORD lof;
  69.  
  70. struct ev eventtab[ev_max];
  71.  
  72. int copper_active;
  73.  
  74. static const int dskdelay = 2; /* FIXME: ??? */
  75.  
  76.  /* 
  77.   * hardware register values that are visible/can be written to by someone
  78.   */
  79.  
  80. static int fmode;
  81.  
  82. static UWORD cregs[256];
  83.  
  84. UWORD intena,intreq;
  85. UWORD dmacon;
  86. UWORD adkcon; /* used by audio code */
  87.  
  88. static ULONG cop1lc,cop2lc,copcon;
  89.  
  90. /* Kludge. FIXME: How does sprite restart after vsync work? */
  91. static int spron[8];
  92. static CPTR sprpt[8];
  93.  
  94. static ULONG bpl1dat,bpl2dat,bpl3dat,bpl4dat,bpl5dat,bpl6dat,bpl7dat,bpl8dat;
  95. static WORD  bpl1mod,bpl2mod;
  96.  
  97. xcolnr acolors[64];
  98.  
  99. UBYTE *r_bplpt[MAX_PLANES];
  100. static CPTR bplpt[MAX_PLANES];
  101.  
  102. /*static int blitcount[256];  blitter debug */
  103.  
  104. struct bplinfo {
  105. #if AGA_CHIPSET == 0
  106.     /* X86.S will break if this isn't at the beginning of the structure. */
  107.     UWORD color_regs[32];
  108. #else
  109.     ULONG color_regs[256];
  110. #endif
  111.     UWORD bplcon0,bplcon1,bplcon2,bplcon3,bplcon4;
  112.     UWORD diwstrt,diwstop,ddfstrt,ddfstop;
  113.  
  114.     UWORD sprdata[8], sprdatb[8], sprctl[8], sprpos[8];
  115.     int sprarmed[8];
  116. } bpl_info;
  117.  
  118. struct line_description
  119. {
  120.     int inborder;
  121.     xcolnr bordercol;
  122.     struct bplinfo bpl_info;
  123.     struct mem_notify_node *mnn;
  124.     CPTR bplpt[MAX_PLANES];
  125.     int linedata_valid;
  126. };
  127.  
  128. static int frame_redraw_necessary;
  129.  
  130. /* 50 words give you 800 horizontal pixels. An A500 can't do that, so it ought
  131.  * to be enough. */
  132. #define MAX_WORDS_PER_LINE 50
  133. static UBYTE line_data[numscrlines * 2][MAX_PLANES][MAX_WORDS_PER_LINE*2];
  134. static struct line_description linedescr[numscrlines * 2];
  135.  
  136. static ULONG dskpt;
  137. static UWORD dsklen,dsksync;
  138.  
  139. static int joy0x, joy1x, joy0y, joy1y;
  140. int joy0button;
  141. UWORD joy0dir;
  142. static int lastspr0x,lastspr0y,lastdiffx,lastdiffy,spr0pos,spr0ctl;
  143. static int mstepx,mstepy,xoffs=defxoffs,yoffs=defyoffs;
  144. static int sprvbfl;
  145.  
  146. static enum { normal_mouse, dont_care_mouse, follow_mouse } mousestate;
  147.  
  148.  /*
  149.   * "hidden" hardware registers
  150.   */
  151.  
  152. int dblpf_ind1[256], dblpf_ind2[256], dblpf_2nd1[256], dblpf_2nd2[256];
  153. int dblpf_aga1[256], dblpf_aga2[256], linear_map_256[256], lots_of_twos[256];
  154.  
  155. int dblpfofs[] = { 0, 2, 4, 8, 16, 32, 64, 128 };
  156.  
  157. static ULONG coplc;
  158. static UWORD copi1,copi2;
  159.  
  160. static enum {
  161.     COP_stop, COP_read, COP_wait, COP_move, COP_skip
  162. } copstate;
  163.  
  164. static int dsklength;
  165.  
  166. int plffirstline,plflastline,plfstrt,plfstop,plflinelen;
  167. int diwfirstword,diwlastword;
  168. int plfpri[3];
  169.  
  170. int max_diwstop, prev_max_diwstop;
  171.  
  172. int dskdmaen; /* used in cia.c */
  173.  
  174. int bpldelay1, bpldelay2;
  175. int bplehb, bplham, bpldualpf, bpldualpfpri, bplplanecnt, bplhires;
  176.  
  177. static int pfield_fullline,pfield_linedone;
  178. static int pfield_linedmaon;
  179. static int pfield_lastpart_hpos,last_sprite;
  180. static int slowline_nextpos, slowline_linepos, slowline_lasttoscr;
  181.  
  182. union {
  183.     /* Let's try to align this thing. */
  184.     double uupzuq;
  185.     long int cruxmedo;
  186.     unsigned char apixels[1000];
  187. } pixdata;
  188.  
  189. char spixels[1000]; /* for sprites */
  190. char spixstate[1000]; /* more sprites */
  191.  
  192. ULONG ham_linebuf[1000];
  193. ULONG aga_linebuf[1000], *aga_lbufptr;
  194.  
  195. char *xlinebuffer;
  196. int next_lineno, linetoscreen, line_in_border;
  197.  
  198. /*
  199.  * Statistics
  200.  */
  201.  
  202. static unsigned long int msecs = 0, frametime = 0, timeframes = 0;
  203. static unsigned long int seconds_base;
  204. int bogusframe;
  205.  
  206. /*
  207.  * helper functions
  208.  */
  209.  
  210. static void pfield_doline_slow(int);
  211. static void pfield_doline(void);
  212. static void do_sprites(int, int);
  213.  
  214. int inhibit_frame;
  215. static int framecnt = 0;
  216.  
  217. static __inline__ void count_frame(void)
  218. {
  219.     if (inhibit_frame) 
  220.         framecnt = 1;
  221.     else {
  222.     framecnt++;
  223.     if (framecnt >= framerate)
  224.             framecnt = 0;
  225.     }
  226. }
  227.  
  228. static __inline__ void setclr(UWORD *p, UWORD val)
  229. {
  230.     if (val & 0x8000) {
  231.     *p |= val & 0x7FFF;
  232.     } else {
  233.     *p &= ~val;
  234.     }
  235. }
  236.  
  237. static __inline__ int current_hpos(void)
  238. {
  239.     return cycles - eventtab[ev_hsync].oldcycles;
  240. }
  241.  
  242. static void calcdiw(void)
  243. {
  244.     if (use_lores) {
  245.     diwfirstword = (bpl_info.diwstrt & 0xFF) - 0x30 - 1;
  246.     diwlastword  = (bpl_info.diwstop & 0xFF) + 0x100 - 0x30 - 1;
  247.     } else {
  248.     diwfirstword = (bpl_info.diwstrt & 0xFF) * 2 - 0x60 - 2;
  249.     diwlastword  = (bpl_info.diwstop & 0xFF) * 2 + 0x200 - 0x60 - 2;
  250.     }
  251.     if (diwfirstword < 0) diwfirstword = 0;
  252.     if (diwlastword > max_diwstop) max_diwstop = diwlastword;
  253.     
  254.     plffirstline = bpl_info.diwstrt >> 8;
  255.     plflastline = bpl_info.diwstop >> 8;
  256. #if 0
  257.     /* This happens far too often. */
  258.     if (plffirstline < minfirstline) {
  259.     fprintf(stderr, "Warning: Playfield begins before line %d!\n", minfirstline);
  260.     plffirstline = minfirstline;
  261.     }
  262. #endif
  263.     if ((plflastline & 0x80) == 0) plflastline |= 0x100;
  264. #if 0 /* Turrican does this */
  265.     if (plflastline > 313) {
  266.     fprintf(stderr, "Warning: Playfield out of range!\n");
  267.     plflastline = 313;
  268.     }
  269. #endif
  270.     plfstrt = bpl_info.ddfstrt;
  271.     plfstop = bpl_info.ddfstop;
  272.     if (plfstrt < 0x18) plfstrt = 0x18;
  273.     if (plfstop > 0xD8) plfstop = 0xD8;
  274.     if (plfstrt > plfstop) plfstrt = plfstop;
  275.  
  276.     /* ! If the masking operation is changed, the pfield_doline code could break
  277.      * on some systems (alignment) */
  278.     /* This actually seems to be correct now, at least the non-AGA stuff... */
  279.     plfstrt &= ~3;
  280.     plfstop &= ~3;
  281.     if ((fmode & 3) == 0)
  282.     plflinelen = (plfstop-plfstrt+15) & ~7;
  283.     else if ((fmode & 3) == 3)
  284.     plflinelen = (plfstop-plfstrt+63) & ~31;
  285.     else
  286.     plflinelen = (plfstop-plfstrt+31) & ~15;
  287.     
  288. }
  289.  
  290. /*
  291.  * Screen update macros/functions
  292.  */
  293.  
  294. static void decode_ham6 (int pix, int stoppos)
  295. {
  296.     static UWORD lastcolor;
  297.     ULONG *buf = ham_linebuf; 
  298.  
  299.     if (!bplham || bplplanecnt != 6)
  300.     return;
  301.     
  302.     if (pix <= diwfirstword) {
  303.     pix = diwfirstword;
  304.     lastcolor = bpl_info.color_regs[0];
  305.     }
  306.  
  307.     while (pix < diwlastword && pix < stoppos) {
  308.     int pv = pixdata.apixels[pix];
  309.     switch(pv & 0x30) {
  310.      case 0x00: lastcolor = bpl_info.color_regs[pv]; break;
  311.      case 0x10: lastcolor &= 0xFF0; lastcolor |= (pv & 0xF); break;
  312.      case 0x20: lastcolor &= 0x0FF; lastcolor |= (pv & 0xF) << 8; break;
  313.      case 0x30: lastcolor &= 0xF0F; lastcolor |= (pv & 0xF) << 4; break;
  314.     }
  315.  
  316.     buf[pix++] = lastcolor;
  317.     }    
  318. }
  319.  
  320. static void decode_ham_aga (int pix, int stoppos)
  321. {
  322.     static ULONG lastcolor;
  323.     ULONG *buf = ham_linebuf; 
  324.  
  325.     if (!bplham || (bplplanecnt != 6 && bplplanecnt != 8))
  326.     return;
  327.     
  328.     if (pix <= diwfirstword) {
  329.     pix = diwfirstword;
  330.     lastcolor = bpl_info.color_regs[0];
  331.     }
  332.  
  333.     if (bplplanecnt == 6) {
  334.     /* HAM 6 */
  335.     while (pix < diwlastword && pix < stoppos) {
  336.         int pv = pixdata.apixels[pix];
  337.         switch(pv & 0x30) {
  338.          case 0x00: lastcolor = bpl_info.color_regs[pv]; break;
  339.          case 0x10: lastcolor &= 0xFFFF00; lastcolor |= (pv & 0xF)*0x11; break;
  340.          case 0x20: lastcolor &= 0x00FFFF; lastcolor |= (pv & 0xF)*0x11 << 16; break;
  341.          case 0x30: lastcolor &= 0xFF00FF; lastcolor |= (pv & 0xF)*0x11 << 8; break;
  342.         }        
  343.         buf[pix++] = lastcolor;
  344.     }
  345.     } else if (bplplanecnt == 8) {
  346.     /* HAM 8 */
  347.     while (pix < diwlastword && pix < stoppos) {
  348.         int pv = pixdata.apixels[pix];
  349.         switch(pv & 0x3) {
  350.          case 0x0: lastcolor = bpl_info.color_regs[pv >> 2]; break;
  351.          case 0x1: lastcolor &= 0xFFFF03; lastcolor |= (pv & 0xFC); break;
  352.          case 0x2: lastcolor &= 0x03FFFF; lastcolor |= (pv & 0xFC) << 16; break;
  353.          case 0x3: lastcolor &= 0xFF03FF; lastcolor |= (pv & 0xFC) << 8; break;
  354.         }
  355.         buf[pix++] = lastcolor;
  356.     }
  357.     }
  358. }
  359.  
  360. #define LINE_TO_SCR(NAME, TYPE, DO_DOUBLE) \
  361. static void NAME(int pix, int stoppos, int offset) \
  362. { \
  363.     TYPE *buf = (TYPE *)xlinebuffer; \
  364.     int oldpix = pix; \
  365.     buf -= pix; \
  366.     if (DO_DOUBLE) offset /= sizeof(TYPE); \
  367.     while (pix < diwfirstword && pix < stoppos) { \
  368.         TYPE d = acolors[0]; \
  369.     buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  370.     pix++; \
  371.     } \
  372.     if (bplham && bplplanecnt == 6) { \
  373.     /* HAM 6 */ \
  374.     while (pix < diwlastword && pix < stoppos) { \
  375.         TYPE d = xcolors[ham_linebuf[pix]]; \
  376.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  377.         pix++; \
  378.     } \
  379.     } else if (bpldualpf) { \
  380.     /* Dual playfield */ \
  381.     int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1; \
  382.     while (pix < diwlastword && pix < stoppos) { \
  383.         int pixcol = pixdata.apixels[pix]; \
  384.         TYPE d; \
  385.         if (spixstate[pix]) { \
  386.         d = acolors[pixcol]; \
  387.         } else { \
  388.         d = acolors[lookup[pixcol]]; \
  389.         } \
  390.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  391.         pix++; \
  392.     } \
  393.     } else { \
  394.     while (pix < diwlastword && pix < stoppos) { \
  395.         TYPE d = acolors[pixdata.apixels[pix]]; \
  396.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  397.         pix++; \
  398.     } \
  399.     } \
  400.     while (pix < stoppos) { \
  401.         TYPE d = acolors[0]; \
  402.     buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  403.     pix++; \
  404.     } \
  405.     xlinebuffer = (char *)(((TYPE *)xlinebuffer) + pix - oldpix); \
  406. }
  407.  
  408. /* WARNING: Not too much of this will work correctly yet. */
  409.  
  410. static void pfield_linetoscr_aga(int pix, int stoppos)
  411. {
  412.     ULONG *buf = aga_lbufptr;
  413.     int i;
  414.     int xor = (UBYTE)(bpl_info.bplcon4 >> 8);
  415.     int oldpix = pix; \
  416.  
  417.     buf -= pix; \
  418.  
  419.     for (i = 0; i < stoppos; i++)
  420.     pixdata.apixels[i] ^= xor;
  421.     
  422.     while (pix < diwfirstword && pix < stoppos) {
  423.     buf[pix++] = bpl_info.color_regs[0];
  424.     }
  425.     if (bplham) {
  426.     while (pix < diwlastword && pix < stoppos) {
  427.         ULONG d = ham_linebuf[pix];
  428.         buf[pix] = d;
  429.         pix++;
  430.     }
  431.     } else if (bpldualpf) {
  432.     /* Dual playfield */
  433.     int *lookup = bpldualpfpri ? dblpf_aga2 : dblpf_aga1;
  434.     int *lookup_no = bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1;
  435.     while (pix < diwlastword && pix < stoppos) {
  436.         int pixcol = pixdata.apixels[pix];
  437.         int pfno = lookup_no[pixcol];
  438.         
  439.         if (spixstate[pix]) {
  440.             buf[pix] = bpl_info.color_regs[pixcol];
  441.         } else {
  442.         int val = lookup[pixdata.apixels[pix]];
  443.         if (pfno == 2) 
  444.             val += dblpfofs[(bpl_info.bplcon2 >> 10) & 7];
  445.         buf[pix] = bpl_info.color_regs[val];
  446.         }
  447.         pix++;
  448.     }
  449.     } else if (bplehb) {
  450.     while (pix < diwlastword && pix < stoppos) {
  451.             int pixcol = pixdata.apixels[pix];
  452.         ULONG d = bpl_info.color_regs[pixcol];
  453.         /* What about sprites? */
  454.         if (pixcol & 0x20)
  455.         d = (d & 0x777777) >> 1;
  456.         buf[pix] = d;
  457.         pix++;
  458.     }
  459.     } else {
  460.     while (pix < diwlastword && pix < stoppos) {
  461.         int pixcol = pixdata.apixels[pix];
  462.         buf[pix] = bpl_info.color_regs[pixcol];
  463.         pix++;
  464.     }
  465.     }
  466.     while (pix < stoppos) {
  467.     buf[pix++] = bpl_info.color_regs[0];
  468.     }
  469.     aga_lbufptr += pix - oldpix;
  470. }
  471.  
  472. static void aga_translate32(int start, int stop)
  473. {
  474.     memcpy (((ULONG *)xlinebuffer) + start, aga_linebuf + start, 4*(stop-start));
  475. }
  476.  
  477. static void aga_translate16(int start, int stop)
  478. {
  479.     int i;
  480.     for (i = start; i < stop; i++) {
  481.     ULONG d = aga_linebuf[i];
  482.     UWORD v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  483.     ((UWORD *)xlinebuffer)[i] = xcolors[v];
  484.     }
  485. }
  486.  
  487. static void aga_translate8(int start, int stop)
  488. {
  489.     int i;
  490.     for (i = start; i < stop; i++) {
  491.     ULONG d = aga_linebuf[i];
  492.     UWORD v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  493.     ((UBYTE *)xlinebuffer)[i] = xcolors[v];
  494.     }
  495. }
  496.  
  497.  
  498.  
  499. #define FILL_LINE(NAME, TYPE) \
  500. static void NAME(char *buf) \
  501. { \
  502.     TYPE *b = (TYPE *)buf; \
  503.     int i;\
  504.     int maxpos = gfxvidinfo.maxlinetoscr; \
  505.     xcolnr col = acolors[0]; \
  506.     if (!maxpos) maxpos = 796; \
  507.     for (i = 0; i < maxpos; i++) \
  508.         *b++ = col; \
  509. }
  510.  
  511. LINE_TO_SCR(pfield_linetoscr_8, UBYTE, 0)
  512. LINE_TO_SCR(pfield_linetoscr_16, UWORD, 0)
  513. LINE_TO_SCR(pfield_linetoscr_32, ULONG, 0)
  514. LINE_TO_SCR(pfield_linetoscr_8_double_slow, UBYTE, 1)
  515. LINE_TO_SCR(pfield_linetoscr_16_double_slow, UWORD, 1)
  516. LINE_TO_SCR(pfield_linetoscr_32_double_slow, ULONG, 1)
  517.  
  518. FILL_LINE(fill_line_8, UBYTE)
  519. FILL_LINE(fill_line_16, UWORD)
  520. FILL_LINE(fill_line_32, ULONG)
  521.  
  522. #define pfield_linetoscr_full8 pfield_linetoscr_8
  523. #define pfield_linetoscr_full16 pfield_linetoscr_16
  524. #define pfield_linetoscr_full32 pfield_linetoscr_32
  525.  
  526. #define pfield_linetoscr_full8_double pfield_linetoscr_8_double_slow
  527. #define pfield_linetoscr_full16_double pfield_linetoscr_16_double_slow
  528. #define pfield_linetoscr_full32_double pfield_linetoscr_32_double_slow
  529.  
  530. #if 1 && defined(X86_ASSEMBLY)
  531. #undef pfield_linetoscr_full8
  532. #undef pfield_linetoscr_full16
  533. extern void pfield_linetoscr_full8(int, int, int) __asm__("pfield_linetoscr_full8");
  534. extern void pfield_linetoscr_full16(int, int, int) __asm__("pfield_linetoscr_full16");
  535. #undef pfield_linetoscr_full8_double
  536. #undef pfield_linetoscr_full16_double
  537.  
  538. static void pfield_linetoscr_full8_double(int start, int stop, int offset)
  539. {
  540.     char *oldxlb = (char *)xlinebuffer;
  541.     pfield_linetoscr_full8(start,stop,offset);
  542.     xlinebuffer = oldxlb + offset;
  543.     pfield_linetoscr_full8(start,stop,offset);
  544. }
  545. static void pfield_linetoscr_full16_double(int start, int stop, int offset)
  546. {
  547.     char *oldxlb = (char *)xlinebuffer;
  548.     pfield_linetoscr_full16(start,stop,offset);
  549.     xlinebuffer = oldxlb + offset;
  550.     pfield_linetoscr_full16(start,stop,offset);
  551. }
  552. #endif
  553.  
  554. static __inline__ void fill_line(int y)
  555. {
  556.     switch (gfxvidinfo.pixbytes) {
  557.      case 1: fill_line_8(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  558.      case 2: fill_line_16(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  559.      case 4: fill_line_32(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  560.     }
  561. }
  562.  
  563. static void pfield_do_linetoscr(int start, int stop)
  564. {
  565.     int factor = use_lores ? 1 : 2;
  566.     int oldstop = stop;
  567.     int real_start, real_stop;
  568.     
  569.     start = PIXEL_XPOS(start);
  570.     if (start < 8*factor)
  571.     start = 8*factor;
  572.     stop = PIXEL_XPOS(stop);
  573.     if (stop > 406*factor)
  574.     stop = 406*factor;
  575.     
  576.     if (start >= stop)
  577.     return;
  578.     if (stop <= gfxvidinfo.x_adjust)
  579.     return;
  580.     
  581.     slowline_lasttoscr = oldstop;
  582.  
  583.     if (start < gfxvidinfo.x_adjust)
  584.     real_start = gfxvidinfo.x_adjust;
  585.     else
  586.     real_start = start;
  587.     
  588.     if (gfxvidinfo.maxlinetoscr) {
  589.     real_stop = gfxvidinfo.x_adjust + gfxvidinfo.maxlinetoscr;
  590.     if (real_stop > stop)
  591.         real_stop = stop;
  592.     } else
  593.     real_stop = stop;
  594.  
  595. #if AGA_CHIPSET == 0
  596.     if (start == 8*factor && stop == 406*factor) {
  597.     switch (gfxvidinfo.pixbytes) {
  598.      case 1: pfield_linetoscr_full8 (real_start, real_stop, 0); break;
  599.      case 2: pfield_linetoscr_full16 (real_start, real_stop, 0); break;
  600.      case 4: pfield_linetoscr_full32 (real_start, real_stop, 0); break;
  601.     }
  602.     } else {
  603.     if (real_start >= real_stop)
  604.         return;
  605.     switch (gfxvidinfo.pixbytes) {
  606.      case 1: pfield_linetoscr_8 (real_start, real_stop, 0); break;
  607.      case 2: pfield_linetoscr_16 (real_start, real_stop, 0); break;
  608.      case 4: pfield_linetoscr_32 (real_start, real_stop, 0); break;
  609.     }
  610.     }
  611. #else
  612.     pfield_linetoscr_aga(real_start, real_stop);
  613. #endif
  614. }
  615.  
  616. static void pfield_do_linetoscr_full(int double_line)
  617. {
  618.     int factor = use_lores ? 1 : 2;
  619.     int stop, start;
  620.     
  621.     start = 8*factor;
  622.     stop = 406*factor;
  623.     
  624.     if (start < gfxvidinfo.x_adjust)
  625.     start = gfxvidinfo.x_adjust;
  626.     
  627.     if (gfxvidinfo.maxlinetoscr) {
  628.     int tmp = gfxvidinfo.x_adjust + gfxvidinfo.maxlinetoscr;
  629.     if (tmp < stop)
  630.         stop = tmp;
  631.     }
  632.  
  633. #if AGA_CHIPSET == 0
  634.     if (double_line) {
  635.     switch (gfxvidinfo.pixbytes) {
  636.      case 1: pfield_linetoscr_full8_double (start, stop, gfxvidinfo.rowbytes); break;
  637.      case 2: pfield_linetoscr_full16_double (start, stop, gfxvidinfo.rowbytes); break;
  638.      case 4: pfield_linetoscr_full32_double (start, stop, gfxvidinfo.rowbytes); break;
  639.     }
  640.     } else 
  641.     switch (gfxvidinfo.pixbytes) {
  642.      case 1: pfield_linetoscr_full8 (start, stop, 0); break;
  643.      case 2: pfield_linetoscr_full16 (start, stop, 0); break;
  644.      case 4: pfield_linetoscr_full32 (start, stop, 0); break;
  645.     }
  646. #else
  647.     pfield_linetoscr_aga(start, stop);
  648. #endif
  649. }
  650.  
  651. /*
  652.  * This function is called whenever a hardware register that controls the
  653.  * screen display is modified. Usually, this routine does nothing. But in
  654.  * some cases, e.g., when a color changes in mid-screen, as in copper-plasma
  655.  * effects, this function switches the update method from the fast full-line
  656.  * update to the much slower single-color-clock update.
  657.  */
  658. static void pfield_may_need_update(int colreg)
  659. {
  660.     int i;
  661.     
  662.     /* Ignore, if this happened before or after the DDF window */
  663.     /* @@@ This breaks some copper plasmas. Not good... maybe a config
  664.      * option is needed. */
  665.     if (framecnt != 0 || !pfield_linedmaon || current_hpos() <= plfstrt
  666.     || vpos < plffirstline || vpos < minfirstline || vpos >= plflastline
  667.     || next_lineno >= gfxvidinfo.maxline)
  668.     {
  669.         return;
  670.     }
  671.     /* 
  672.      * If a color reg was modified, it is only important if we are within
  673.      * the DIW.
  674.      */
  675.     if (PIXEL_XPOS(current_hpos()) <= diwfirstword && colreg)
  676.         return;
  677.  
  678.     /*
  679.      * If we are past the DDF window, me might as well draw the complete
  680.      * line now.
  681.      */
  682.     if (current_hpos() > plfstrt + plflinelen && pfield_fullline) {
  683.     if (!pfield_linedone)
  684.         pfield_doline();
  685.     pfield_linedone = 1;
  686.     return;
  687.     }
  688.         
  689.     do_sprites(vpos, current_hpos());
  690.     if (pfield_fullline) {
  691.     pfield_lastpart_hpos = 0;
  692.     memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  693.     memset(spixstate,0,sizeof spixstate);
  694.     pfield_fullline = 0;
  695.     slowline_nextpos = -1;
  696.     slowline_linepos = 0;
  697.     slowline_lasttoscr = 0;
  698.     } else {    
  699.     assert(pfield_lastpart_hpos <= current_hpos());
  700.     }
  701.     for (i = pfield_lastpart_hpos; i < current_hpos(); i++) {
  702.     pfield_doline_slow(i);
  703.     }
  704.     if (colreg) {
  705.     pfield_do_linetoscr(slowline_lasttoscr, current_hpos());
  706.     }
  707.     pfield_lastpart_hpos = current_hpos();
  708. }
  709.  
  710. /* Apparently, the DMA bit is tested by the hardware at some point,
  711.  * presumably at the ddfstart position, to determine whether it
  712.  * ought to draw the line.
  713.  * This is probably not completely correct, but should not matter
  714.  * very much.
  715.  */
  716. static void pfield_calclinedma(void)
  717. {
  718.     if (current_hpos() >= plfstrt)
  719.         return;
  720.     
  721.     pfield_linedmaon = dmaen(DMA_BITPLANE);
  722. }
  723.  
  724.  /* 
  725.   * register functions
  726.   */
  727.  
  728. static UWORD DMACONR(void)
  729. {
  730.     return (dmacon | (bltstate==BLT_done ? 0 : 0x4000)
  731.         | (blt_info.blitzero ? 0x2000 : 0));
  732. }
  733. static UWORD INTENAR(void) { return intena; }
  734. UWORD INTREQR(void)
  735. {
  736.     return intreq | (use_serial ? 0x0001 : 0);
  737. }
  738. static UWORD ADKCONR(void) { return adkcon; }
  739. static UWORD VPOSR(void) 
  740. {
  741. #if AGA_CHIPSET == 1
  742.     return (vpos >> 8) | lof | 0x2300;
  743. #elif defined (ECS_AGNUS)
  744.     return (vpos >> 8) | lof | 0x2000;
  745. #else
  746.     return (vpos >> 8) | lof;
  747. #endif
  748. }
  749. static void  VPOSW(UWORD v)  { lof = v & 0x8000; }
  750. static UWORD VHPOSR(void) { return (vpos << 8) | current_hpos(); } 
  751.  
  752. static void  COP1LCH(UWORD v) { cop1lc= (cop1lc & 0xffff) | ((ULONG)v << 16); }
  753. static void  COP1LCL(UWORD v) { cop1lc= (cop1lc & ~0xffff) | v; }
  754. static void  COP2LCH(UWORD v) { cop2lc= (cop2lc & 0xffff) | ((ULONG)v << 16); }
  755. static void  COP2LCL(UWORD v) { cop2lc= (cop2lc & ~0xffff) | v; }
  756.  
  757. static void  COPJMP1(UWORD a)
  758. {
  759.     coplc = cop1lc; copstate = COP_read; 
  760.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  761.     eventtab[ev_copper].evtime = 4 + cycles; events_schedule();
  762.     copper_active = 1;
  763. }
  764. static void  COPJMP2(UWORD a)
  765. {
  766.     coplc = cop2lc; copstate = COP_read; 
  767.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  768.     eventtab[ev_copper].evtime = 4 + cycles; events_schedule();
  769.     copper_active = 1;
  770. }
  771.  
  772. static void  DMACON(UWORD v) 
  773. {
  774.     int i, need_resched = 0;
  775.  
  776.     UWORD oldcon = dmacon;
  777.     setclr(&dmacon,v); dmacon &= 0x1FFF;
  778.     pfield_calclinedma();
  779.     
  780.     /* FIXME? Maybe we need to think a bit more about the master DMA enable 
  781.      * bit in these cases. */
  782.     if ((dmacon & DMA_COPPER) > (oldcon & DMA_COPPER)) { 
  783.     COPJMP1(0);
  784.     }
  785.     if ((dmacon & DMA_SPRITE) > (oldcon & DMA_SPRITE)) {
  786.     int i;
  787.     for (i = 0; i < 8; i++)
  788.         spron[i] = 1;
  789.     }
  790.     if ((dmacon & DMA_BLITPRI) > (oldcon & DMA_BLITPRI) && bltstate != BLT_done) {
  791.     static int count = 0;
  792.     if (!count) {
  793.         count = 1;
  794.         fprintf(stderr, "warning: program is doing blitpri hacks.\n");
  795.     }
  796.     regs.spcflags |= SPCFLAG_BLTNASTY;
  797.     }
  798. #ifndef DONT_WANT_SOUND
  799.     for (i = 0; i < 4; i++) {
  800.     struct audio_channel_data *cdp = audio_channel + i;
  801.     
  802.     cdp->dmaen = (dmacon & 0x200) && (dmacon & (1<<i));
  803.     if (cdp->dmaen) {
  804.         if (cdp->state == 0) {
  805.         cdp->state = 1;
  806.         cdp->pt = cdp->lc;
  807.         cdp->wper = cdp->per;
  808.         cdp->wlen = cdp->len;
  809.         cdp->data_written = 2;
  810.         eventtab[ev_aud0 + i].oldcycles = eventtab[ev_hsync].oldcycles;
  811.         eventtab[ev_aud0 + i].evtime = eventtab[ev_hsync].evtime;
  812.         eventtab[ev_aud0 + i].active = 1;
  813.         need_resched = 1; /* not _really_ necessary here, but... */
  814.         }
  815.     } else {
  816.         if (cdp->state == 1 || cdp->state == 5) {
  817.         cdp->state = 0;
  818.         cdp->current_sample = 0;
  819.         eventtab[ev_aud0 + i].active = 0;
  820.         need_resched = 1;
  821.         }
  822.     }
  823.     }
  824. #endif
  825.     if (copper_active && !eventtab[ev_copper].active) {
  826.     eventtab[ev_copper].active = 1;
  827.     eventtab[ev_copper].oldcycles = cycles;
  828.     eventtab[ev_copper].evtime = 1 + cycles;
  829.     need_resched = 1;
  830.     }
  831.     if (need_resched)
  832.     events_schedule();
  833. }
  834. static void  INTENA(UWORD v) { setclr(&intena,v); regs.spcflags |= SPCFLAG_INT; }
  835. void  INTREQ(UWORD v)
  836. {
  837.   setclr(&intreq,v);
  838.   regs.spcflags |= SPCFLAG_INT;
  839.   if ((v&0x8800)==0x0800) serdat&=0xbfff;
  840.  }
  841.  
  842. static void  ADKCON(UWORD v) { setclr(&adkcon,v); }
  843.  
  844. static void  BPLPTH(UWORD v, int num) { bplpt[num] = (bplpt[num] & 0xffff) | ((ULONG)v << 16); }
  845. static void  BPLPTL(UWORD v, int num) { bplpt[num] = (bplpt[num] & ~0xffff) | (v & 0xFFFE); }
  846.  
  847. /*
  848.  * I've seen the listing of an example program that changes 
  849.  * from lo- to hires while a line is being drawn. That's
  850.  * awful, but we want to emulate it.
  851.  */
  852. static void  BPLCON0(UWORD v) 
  853. {
  854.     if (bpl_info.bplcon0 == v)
  855.     return;
  856.     pfield_may_need_update(0);
  857.     bpl_info.bplcon0 = v;
  858.     bplhires = (v & 0x8000) == 0x8000;
  859.     bplplanecnt = (v & 0x7000) >> 12;
  860.     bplham = (v & 0x800) == 0x800;
  861.     bpldualpf = (v & 0x400) == 0x400;
  862.     bplehb = (v & 0xFDC0) == 0x6000 && !(bpl_info.bplcon2 & 0x200); /* see below */
  863.     calcdiw(); /* This should go away. */
  864. }
  865. static void  BPLCON1(UWORD v) 
  866. {
  867.     if (bpl_info.bplcon1 == v)
  868.     return;
  869.     pfield_may_need_update(0);
  870.     bpl_info.bplcon1 = v; 
  871.     bpldelay1 = v & 0xF; 
  872.     bpldelay2 = (v >> 4) & 0xF; 
  873. }
  874. static void  BPLCON2(UWORD v) 
  875. {
  876.     if (bpl_info.bplcon2 == v)
  877.     return;
  878.     pfield_may_need_update(0); 
  879.     bpl_info.bplcon2 = v;
  880.     bpldualpfpri = (v & 0x40) == 0x40;
  881.     plfpri[1] = 1 << 2*(v & 7);
  882.     plfpri[2] = 1 << 2*((v>>3) & 7);
  883.     bplehb = (bpl_info.bplcon0 & 0xFDC0) == 0x6000 && !(v & 0x200); /* see above */
  884. }
  885. static void  BPLCON3(UWORD v) 
  886. {
  887.     if (bpl_info.bplcon3 == v)
  888.     return;
  889.     pfield_may_need_update(0); 
  890.     bpl_info.bplcon3 = v; 
  891. }
  892. static void  BPLCON4(UWORD v) 
  893. {
  894.     if (bpl_info.bplcon4 == v)
  895.     return;
  896.     pfield_may_need_update(0); 
  897.     bpl_info.bplcon4 = v; 
  898. }
  899.  
  900. static void  BPL1MOD(UWORD v)
  901. {
  902.     v &= ~1;
  903.     if (bpl1mod == v)
  904.     return;
  905.     pfield_may_need_update(0); 
  906.     bpl1mod = v;
  907. }
  908. static void  BPL2MOD(UWORD v)
  909. { 
  910.     v &= ~1;
  911.     if (bpl2mod == v)
  912.     return;
  913.     pfield_may_need_update(0); 
  914.     bpl2mod = v;
  915. }
  916.  
  917. static void  BPL1DAT(UWORD v) { bpl1dat = v; }
  918. static void  BPL2DAT(UWORD v) { bpl2dat = v; }
  919. static void  BPL3DAT(UWORD v) { bpl3dat = v; }
  920. static void  BPL4DAT(UWORD v) { bpl4dat = v; }
  921. static void  BPL5DAT(UWORD v) { bpl5dat = v; }
  922. static void  BPL6DAT(UWORD v) { bpl6dat = v; }
  923.  
  924. /* We call pfield_may_need_update() from here. Actually, 
  925.  * I have no idea what happens if someone changes ddf or
  926.  * diw mid-line, and I don't really want to know. I doubt
  927.  * that this sort of thing was ever used to create a
  928.  * useful effect.
  929.  */
  930. static void  DIWSTRT(UWORD v) 
  931. {
  932.     if (bpl_info.diwstrt == v)
  933.     return;
  934.     pfield_may_need_update(0);
  935.     bpl_info.diwstrt = v; 
  936.     calcdiw();
  937. }
  938. static void  DIWSTOP(UWORD v)
  939. {
  940.     if (bpl_info.diwstop == v)
  941.     return;
  942.     pfield_may_need_update(0);
  943.     bpl_info.diwstop = v; 
  944.     calcdiw();
  945. }
  946. static void  DDFSTRT(UWORD v)
  947. { 
  948.     if (bpl_info.ddfstrt == v)
  949.     return;
  950.     pfield_may_need_update(0);
  951.     bpl_info.ddfstrt = v; 
  952.     calcdiw();
  953. }
  954. static void  DDFSTOP(UWORD v) 
  955. { 
  956.     if (bpl_info.ddfstop == v)
  957.     return;
  958.     pfield_may_need_update(0); 
  959.     bpl_info.ddfstop = v;
  960.     calcdiw();
  961. }
  962.  
  963. static void  BLTADAT(UWORD v) 
  964. {
  965.     maybe_blit(); 
  966.     blt_info.bltadat = v; 
  967. }
  968. static void  BLTBDAT(UWORD v)
  969. {
  970.     maybe_blit(); 
  971.     blt_info.bltbdat = v; 
  972. }
  973. static void  BLTCDAT(UWORD v) { maybe_blit(); blt_info.bltcdat = v; }
  974.  
  975. static void  BLTAMOD(UWORD v) { maybe_blit(); blt_info.bltamod = v & 0xFFFE; }
  976. static void  BLTBMOD(UWORD v) { maybe_blit(); blt_info.bltbmod = v & 0xFFFE; }
  977. static void  BLTCMOD(UWORD v) { maybe_blit(); blt_info.bltcmod = v & 0xFFFE; }
  978. static void  BLTDMOD(UWORD v) { maybe_blit(); blt_info.bltdmod = v & 0xFFFE; }
  979.  
  980. static void  BLTCON0(UWORD v) { maybe_blit(); bltcon0 = v; blinea_shift = v >> 12; }
  981. /* The next category is "Most useless hardware register". 
  982.  * And the winner is... */
  983. static void  BLTCON0L(UWORD v) { maybe_blit(); bltcon0 = (bltcon0 & 0xFF00) | (v & 0xFF); }
  984. static void  BLTCON1(UWORD v) { maybe_blit(); bltcon1 = v; }
  985.  
  986. static void  BLTAFWM(UWORD v) { maybe_blit(); blt_info.bltafwm = v; }
  987. static void  BLTALWM(UWORD v) { maybe_blit(); blt_info.bltalwm = v; }
  988.  
  989. static void  BLTAPTH(UWORD v) { maybe_blit(); bltapt= (bltapt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  990. static void  BLTAPTL(UWORD v) { maybe_blit(); bltapt= (bltapt & ~0xffff) | (v & 0xFFFE); }
  991. static void  BLTBPTH(UWORD v) { maybe_blit(); bltbpt= (bltbpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  992. static void  BLTBPTL(UWORD v) { maybe_blit(); bltbpt= (bltbpt & ~0xffff) | (v & 0xFFFE); }
  993. static void  BLTCPTH(UWORD v) { maybe_blit(); bltcpt= (bltcpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  994. static void  BLTCPTL(UWORD v) { maybe_blit(); bltcpt= (bltcpt & ~0xffff) | (v & 0xFFFE); }
  995. static void  BLTDPTH(UWORD v) { maybe_blit(); bltdpt= (bltdpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  996. static void  BLTDPTL(UWORD v) { maybe_blit(); bltdpt= (bltdpt & ~0xffff) | (v & 0xFFFE); }
  997. static void  BLTSIZE(UWORD v) 
  998. {
  999.     bltsize = v;
  1000.     
  1001.     maybe_blit(); 
  1002.  
  1003.     blt_info.vblitsize = bltsize >> 6;
  1004.     blt_info.hblitsize = bltsize & 0x3F;
  1005.     if (!blt_info.vblitsize) blt_info.vblitsize = 1024;
  1006.     if (!blt_info.hblitsize) blt_info.hblitsize = 64;
  1007.     
  1008.     bltstate = BLT_init; 
  1009.     regs.spcflags |= SPCFLAG_BLIT; 
  1010. }
  1011. static void BLTSIZV(UWORD v) 
  1012. {
  1013.     maybe_blit(); 
  1014.     oldvblts = v & 0x7FFF;
  1015. }
  1016. static void BLTSIZH(UWORD v) 
  1017. {
  1018.     maybe_blit(); 
  1019.     blt_info.hblitsize = v & 0x7FF;
  1020.     blt_info.vblitsize = oldvblts;
  1021.     if (!blt_info.vblitsize) blt_info.vblitsize = 32768;
  1022.     if (!blt_info.hblitsize) blt_info.hblitsize = 0x800;
  1023.     bltstate = BLT_init; 
  1024.     regs.spcflags |= SPCFLAG_BLIT;
  1025. }
  1026. static void  SPRxCTL_1(UWORD v, int num)
  1027. {
  1028.     bpl_info.sprctl[num] = v;
  1029.     bpl_info.sprarmed[num] = 0;
  1030.     if (bpl_info.sprpos[num] == 0 && v == 0)
  1031.     spron[num] = 0;
  1032.     else
  1033.     spron[num] |= 2;
  1034. }
  1035. static void  SPRxPOS_1(UWORD v, int num) 
  1036. {
  1037.     bpl_info.sprpos[num] = v; 
  1038. }
  1039. static void  SPRxDATA_1(UWORD v, int num)
  1040. {
  1041.     bpl_info.sprdata[num] = v;
  1042.     bpl_info.sprarmed[num] = 1; 
  1043. }
  1044. static void  SPRxDATB_1(UWORD v, int num) 
  1045. {
  1046.     bpl_info.sprdatb[num] = v;
  1047. }
  1048. static void  SPRxCTL(UWORD v, int num) { pfield_may_need_update(0); SPRxCTL_1(v, num); }
  1049. static void  SPRxPOS(UWORD v, int num) { pfield_may_need_update(0); SPRxPOS_1(v, num); }
  1050. static void  SPRxDATA(UWORD v, int num){ pfield_may_need_update(0); SPRxDATA_1(v, num); }
  1051. static void  SPRxDATB(UWORD v, int num){ pfield_may_need_update(0); SPRxDATB_1(v, num); }
  1052. static void  SPRxPTH(UWORD v, int num)
  1053. {
  1054.     sprpt[num] &= 0xffff; 
  1055.     sprpt[num] |= (ULONG)v << 16; 
  1056.     if (!spron[num]) spron[num] = 1; 
  1057. }
  1058. static void  SPRxPTL(UWORD v, int num)
  1059. {
  1060.     sprpt[num] &= ~0xffff; 
  1061.     sprpt[num] |= v; 
  1062.     if (!spron[num]) spron[num] = 1; 
  1063. }
  1064.  
  1065. static void  COLOR(UWORD v, int num)
  1066. {
  1067.     int r,g,b;
  1068.     int cr,cg,cb;
  1069.     int colreg;
  1070.     
  1071.     v &= 0xFFF;
  1072. #if AGA_CHIPSET == 1
  1073.     {
  1074.     ULONG cval;
  1075.     colreg = ((bpl_info.bplcon3 >> 13) & 7) * 32 + num;
  1076.     r = (v & 0xF00) >> 8;
  1077.     g = (v & 0xF0) >> 4;
  1078.     b = (v & 0xF) >> 0;
  1079.     cr = bpl_info.color_regs[colreg] >> 16;
  1080.     cg = (bpl_info.color_regs[colreg] >> 8) & 0xFF;
  1081.     cb = bpl_info.color_regs[colreg] & 0xFF;
  1082.  
  1083.     if (bpl_info.bplcon3 & 0x200) {
  1084.         cr &= 0xF0; cr |= r;
  1085.         cg &= 0xF0; cg |= g;
  1086.         cb &= 0xF0; cb |= b;
  1087.     } else {
  1088.         cr = r + (r << 4);
  1089.         cg = g + (g << 4);
  1090.         cb = b + (b << 4);
  1091.     }
  1092.     cval = (cr << 16) | (cg << 8) | cb;
  1093.     if (cval == bpl_info.color_regs[colreg])
  1094.         return;
  1095.     bpl_info.color_regs[colreg] = cval;
  1096.     pfield_may_need_update(1);
  1097.     }
  1098. #else 
  1099.     {
  1100.     if (bpl_info.color_regs[num] == v)
  1101.         return;
  1102.     pfield_may_need_update(1);
  1103.     bpl_info.color_regs[num] = v;
  1104.     acolors[num] = xcolors[v];
  1105.     acolors[num+32] = xcolors[(v >> 1) & 0x777];
  1106.     }
  1107. #endif
  1108. }
  1109.  
  1110. static void  DSKSYNC(UWORD v) { dsksync = v; }
  1111. static void  DSKDAT(UWORD v) { fprintf(stderr, "DSKDAT written. Not good.\n"); }
  1112. static void  DSKPTH(UWORD v) { dskpt = (dskpt & 0xffff) | ((ULONG)v << 16); }
  1113. static void  DSKPTL(UWORD v) { dskpt = (dskpt & ~0xffff) | (v); }
  1114.  
  1115. static void  DSKLEN(UWORD v) 
  1116. {
  1117.     if (v & 0x8000) {
  1118.     dskdmaen = dskdmaen == 1 ? 2 : 1;
  1119.     } else { 
  1120.     dskdmaen = 0;
  1121.     if (eventtab[ev_diskblk].active)
  1122.         fprintf(stderr, "warning: Disk DMA aborted!\n");
  1123.     eventtab[ev_diskblk].active = 0;
  1124.     events_schedule();
  1125.     
  1126.     }
  1127.     dsklen = dsklength = v; dsklength &= 0x3fff;
  1128.     if (dskdmaen == 2 && dsksync != 0x4489 && (adkcon & 0x400)) {
  1129.     fprintf(stderr, "Non-standard sync: %04x len: %x\n", dsksync, dsklength);
  1130.     }
  1131.     if (dskdmaen > 1) {
  1132.     if (dsklen & 0x4000) {
  1133.         eventtab[ev_diskblk].active = 1;
  1134.         eventtab[ev_diskblk].oldcycles = cycles;
  1135.         eventtab[ev_diskblk].evtime = 40 + cycles; /* ??? */
  1136.         events_schedule();
  1137.     } else {
  1138.         int result = DISK_PrepareReadMFM(dsklength, dsksync, adkcon & 0x400);
  1139.         if (result) {
  1140.         eventtab[ev_diskblk].active = 1;
  1141.         eventtab[ev_diskblk].oldcycles = cycles;
  1142.         eventtab[ev_diskblk].evtime = result + cycles;
  1143.         events_schedule();
  1144.         }
  1145.     }
  1146.     }
  1147. }
  1148.  
  1149. static UWORD DSKBYTR(void)
  1150. {
  1151.     UWORD v = (dsklen >> 1) & 0x6000;
  1152.     UWORD mfm, byte;
  1153.     if (DISK_GetData(&mfm, &byte))
  1154.     v |= 0x8000;
  1155.     v |= byte;
  1156.     if (dsksync == mfm) v |= 0x1000;
  1157.     return v;
  1158. }
  1159.  
  1160. static UWORD DSKDATR(void) 
  1161. {
  1162.     UWORD mfm, byte;
  1163.     DISK_GetData(&mfm, &byte);
  1164.     return mfm; 
  1165. }
  1166. static UWORD POTGOR(void)
  1167. {
  1168.     UWORD v = 0xFF00;
  1169.     if (buttonstate[2])
  1170.     v &= 0xFBFF;
  1171.  
  1172.     if (buttonstate[1])
  1173.     v &= 0xFEFF;
  1174.     
  1175.     return v;
  1176. }
  1177. static UWORD POT0DAT(void)
  1178. {
  1179.     static UWORD cnt = 0;
  1180.     if (buttonstate[2])
  1181.     cnt = ((cnt + 1) & 0xFF) | (cnt & 0xFF00);
  1182.     if (buttonstate[1])
  1183.     cnt += 0x100;
  1184.     
  1185.     return cnt;
  1186. }
  1187. static UWORD JOY0DAT(void) { return joy0x + (joy0y << 8); }
  1188. static UWORD JOY1DAT(void)
  1189. {
  1190.     return joy0dir;
  1191. }
  1192. static void JOYTEST(UWORD v)
  1193. {
  1194.     joy0x = joy1x = v & 0xFC;
  1195.     joy0y = joy1y = (v >> 8) & 0xFC;    
  1196. }
  1197. static void AUDxLCH(int nr, UWORD v) { audio_channel[nr].lc = (audio_channel[nr].lc & 0xffff) | ((ULONG)v << 16); }
  1198. static void AUDxLCL(int nr, UWORD v) { audio_channel[nr].lc = (audio_channel[nr].lc & ~0xffff) | (v & 0xFFFE); }
  1199. static void AUDxPER(int nr, UWORD v)
  1200. {
  1201.     static int warned = 0;
  1202.     if (v <= 0) {
  1203.     if (!warned)
  1204.         fprintf(stderr, "Broken program accessing the sound hardware\n"), warned++;
  1205.     v = 65535;
  1206.     }
  1207.  
  1208.     if (v < maxhpos/2 && produce_sound < 3)
  1209.     v = maxhpos/2;
  1210.  
  1211.     audio_channel[nr].per = v;
  1212. }
  1213.  
  1214. static void AUDxVOL(int nr, UWORD v) { audio_channel[nr].vol = v & 64 ? 63 : v & 63; }
  1215. static void AUDxLEN(int nr, UWORD v) { audio_channel[nr].len = v; }
  1216.  
  1217. static int copcomp(void)
  1218. {
  1219.     UWORD vp = vpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1220.     UWORD hp = current_hpos() & (copi2 & 0xFE);
  1221.     UWORD vcmp = copi1 >> 8;
  1222.     UWORD hcmp = copi1 & 0xFE;
  1223.     return (vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000));
  1224. }
  1225.  
  1226. /*
  1227.  * Calculate the minimum number of cycles after which the
  1228.  * copper comparison becomes true. This is quite tricky. I hope it works.
  1229.  */
  1230. static int calc_copcomp_true(int currvpos, int currhpos)
  1231. {    
  1232.     UWORD vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1233.     UWORD hp = currhpos & (copi2 & 0xFE);
  1234.     UWORD vcmp = copi1 >> 8;
  1235.     UWORD hcmp = copi1 & 0xFE;
  1236.     int copper_time_hpos;
  1237.     int cycleadd = maxhpos - currhpos;
  1238.     int coptime = 0;
  1239.  
  1240.     if ((vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000)))
  1241.         return 0;    
  1242.  
  1243.     try_again:
  1244.  
  1245.     while (vp < vcmp) {
  1246.     currvpos++;
  1247.     if (currvpos > maxvpos + 1)
  1248.         return -1;
  1249.     currhpos = 0;
  1250.     coptime += cycleadd;
  1251.     cycleadd = maxhpos;
  1252.     vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1253.     }
  1254.     if (coptime > 0 && bplhires && bplplanecnt == 4)
  1255.     return coptime;
  1256.     copper_time_hpos = currhpos;
  1257.     hp = copper_time_hpos & (copi2 & 0xFE);
  1258.     if (!(vp > vcmp)) {    
  1259.     while (hp < hcmp-2) {
  1260.         currhpos++;
  1261.         /* Copper DMA is turned off in Hires 4 bitplane mode */
  1262.         if (!bplhires || bplplanecnt < 4 || !dmaen(DMA_BITPLANE)
  1263.         || currhpos < plfstrt-2 || currhpos > (plfstop+4))
  1264.         copper_time_hpos++;
  1265.         
  1266.         if (currhpos > maxhpos-4) {
  1267.         /* Now, what? There might be a good position on the
  1268.          * next line. But it can also be the FFFF FFFE
  1269.          * case.
  1270.          */
  1271.         currhpos = 0;
  1272.         currvpos++;
  1273.         vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1274.         goto try_again;
  1275.         }
  1276.         coptime++;
  1277.         hp = copper_time_hpos & (copi2 & 0xFE);
  1278.     }
  1279.     }
  1280.     if (coptime == 0) /* waiting for the blitter */
  1281.         return 1;
  1282.  
  1283.     return coptime;
  1284. }
  1285.  
  1286. static void copper_read(void)
  1287. {
  1288.     if (dmaen(DMA_COPPER)){
  1289.     copi1 = chipmem_bank.wget(coplc); 
  1290.     copi2 = chipmem_bank.wget(coplc+2);
  1291.     coplc += 4;
  1292.     eventtab[ev_copper].oldcycles = cycles;
  1293.     eventtab[ev_copper].evtime = ((copi1 & 1) ? (copi2 & 1) ? 10 : 8 : 4) + cycles;
  1294.     copstate = (copi1 & 1) ? (copi2 & 1) ? COP_skip : COP_wait : COP_move;
  1295.     } else {
  1296.     copstate = COP_read;
  1297.     eventtab[ev_copper].active = 0;
  1298.     }
  1299. }
  1300.  
  1301. static void do_copper(void)
  1302. {    
  1303.     switch(copstate){
  1304.      case COP_read:
  1305.     copper_read();
  1306.     break;
  1307.      case COP_move:
  1308.     if (copi1 >= (copcon & 2 ? 0x40 : 0x80)) {
  1309.         custom_bank.wput(copi1,copi2);
  1310.         copper_read();
  1311.     } else {
  1312.         copstate = COP_stop;
  1313.         eventtab[ev_copper].active = 0;
  1314.         copper_active = 0;
  1315.     }
  1316.     break;
  1317.      case COP_skip:
  1318.     if (calc_copcomp_true(vpos, current_hpos()) == 0)
  1319.         coplc += 4;
  1320.     copper_read();
  1321.     break;
  1322.      case COP_wait: {        
  1323.      int coptime = calc_copcomp_true(vpos, current_hpos());
  1324.      if (coptime < 0) {
  1325.          copstate = COP_stop;
  1326.          eventtab[ev_copper].active = 0;
  1327.          copper_active = 0;
  1328.      } else {         
  1329.          if (!coptime)
  1330.               copper_read();
  1331.          else {
  1332.          eventtab[ev_copper].evtime = coptime + cycles;
  1333.          eventtab[ev_copper].oldcycles = cycles;
  1334.          }
  1335.      }
  1336.      break;
  1337.      }
  1338.      case COP_stop:
  1339.     eventtab[ev_copper].active = 0;
  1340.     copper_active = 0;
  1341.     break;
  1342.     }
  1343. }
  1344.  
  1345. static void diskblk_handler(void)
  1346. {
  1347.     regs.spcflags |= SPCFLAG_DISK;
  1348.     eventtab[ev_diskblk].active = 0;
  1349. }
  1350.  
  1351. void do_disk(void)
  1352. {
  1353.     if (dskdmaen != 2 && (regs.spcflags & SPCFLAG_DISK)) {
  1354.     fprintf(stderr, "BUG!\n");
  1355.     return;
  1356.     }
  1357.     if (dmaen(0x10)){
  1358.     if (dsklen & 0x4000) {
  1359.         if (!chipmem_bank.check (dskpt, 2*dsklength)) {
  1360.         fprintf(stderr, "warning: Bad disk write DMA pointer\n");
  1361.         } else {
  1362.         UBYTE *mfmp = get_real_address (dskpt);
  1363.         int i;
  1364.         DISK_InitWrite();
  1365.  
  1366.         for (i = 0; i < dsklength; i++) {
  1367.             UWORD d = (*mfmp << 8) + *(mfmp+1);
  1368.             mfmwrite[i] = d;
  1369.             mfmp += 2;
  1370.         }
  1371.         DISK_WriteData(dsklength);
  1372.         }
  1373.     } else {
  1374.         int result = DISK_ReadMFM (dskpt);
  1375.     }
  1376.     regs.spcflags &= ~SPCFLAG_DISK;
  1377.     INTREQ(0x9002);
  1378.     dskdmaen = -1;
  1379.     }
  1380. }
  1381.  
  1382. static __inline__ void pfield_fetchdata(void)
  1383. {
  1384.     if (dmaen(0x100) && pfield_linedmaon) {
  1385.     switch(bplplanecnt){
  1386.      case 8:
  1387.         bpl8dat = chipmem_bank.wget(bplpt[7]); bplpt[7] += 2; bpl8dat <<= 7;
  1388.      case 7:
  1389.         bpl7dat = chipmem_bank.wget(bplpt[6]); bplpt[6] += 2; bpl7dat <<= 6;
  1390.      case 6:
  1391.         bpl6dat = chipmem_bank.wget(bplpt[5]); bplpt[5] += 2; bpl6dat <<= 5;
  1392.      case 5:
  1393.         bpl5dat = chipmem_bank.wget(bplpt[4]); bplpt[4] += 2; bpl5dat <<= 4;
  1394.      case 4:
  1395.         bpl4dat = chipmem_bank.wget(bplpt[3]); bplpt[3] += 2; bpl4dat <<= 3;
  1396.      case 3:
  1397.         bpl3dat = chipmem_bank.wget(bplpt[2]); bplpt[2] += 2; bpl3dat <<= 2;
  1398.      case 2:
  1399.         bpl2dat = chipmem_bank.wget(bplpt[1]); bplpt[1] += 2; bpl2dat <<= 1;
  1400.      case 1:
  1401.         bpl1dat = chipmem_bank.wget(bplpt[0]); bplpt[0] += 2;
  1402.     }
  1403.     }
  1404. }
  1405.  
  1406. static void do_sprites(int currvp, int currhp)
  1407. {   
  1408.     int i;
  1409.     int maxspr = currhp/4 - 0x18/4;
  1410.     
  1411.     if (currvp == 0)
  1412.     return;
  1413.     if (maxspr < 0)
  1414.     return;
  1415.     if (maxspr > 7)
  1416.     maxspr = 7;
  1417.     
  1418.     for(i = last_sprite; i <= maxspr; i++) {
  1419.     int vstart = (bpl_info.sprpos[i] >> 8) | ((bpl_info.sprctl[i] << 6) & 0x100);
  1420.     int vstop = (bpl_info.sprctl[i] >> 8) | ((bpl_info.sprctl[i] << 7) & 0x100);
  1421.     if ((vstart <= currvp && vstop >= currvp) || spron[i] == 1) {
  1422.         if (dmaen(0x20)) {
  1423.         UWORD data1 = chipmem_bank.wget(sprpt[i]);
  1424.         UWORD data2 = chipmem_bank.wget(sprpt[i]+2);
  1425.         sprpt[i] += 4;
  1426.         
  1427.         if (vstop != currvp && spron[i] != 1) {
  1428.             /* Hack for X mouse auto-calibration */
  1429.             if (i == 0 && !sprvbfl && ((bpl_info.sprpos[0]&0xff)<<2)>0x60) {
  1430.             spr0ctl=bpl_info.sprctl[0];
  1431.             spr0pos=bpl_info.sprpos[0];
  1432.             sprvbfl=2;
  1433.             }
  1434.             SPRxDATB_1(data2, i);
  1435.             SPRxDATA_1(data1, i);
  1436.         } else {
  1437.             SPRxPOS_1(data1, i);
  1438.             SPRxCTL_1(data2, i);
  1439.         }
  1440.         }
  1441.     }
  1442.     }
  1443.     last_sprite = maxspr + 1;
  1444. }
  1445.  
  1446. static __inline__ void pfield_modulos(int add)
  1447. {
  1448.     switch(bplplanecnt){
  1449.      case 8:
  1450.     bplpt[7] += add + bpl2mod;
  1451.      case 7:
  1452.     bplpt[6] += add + bpl1mod;
  1453.      case 6:
  1454.     bplpt[5] += add + bpl2mod;
  1455.      case 5:
  1456.     bplpt[4] += add + bpl1mod;
  1457.      case 4:
  1458.     bplpt[3] += add + bpl2mod;
  1459.      case 3:
  1460.     bplpt[2] += add + bpl1mod;
  1461.      case 2:
  1462.     bplpt[1] += add + bpl2mod;
  1463.      case 1:
  1464.     bplpt[0] += add + bpl1mod;
  1465.     }
  1466. }
  1467.  
  1468. #if AGA_CHIPSET == 0
  1469. static void pfield_sprite (int num, int sprxp, UWORD data, UWORD datb, int lores)
  1470. {
  1471.     int i;
  1472.  
  1473.     int *lookup = bpldualpf ? (bpldualpfpri ? dblpf_ind2 : dblpf_ind1) : linear_map_256;
  1474.     int *lookup_no = bpldualpf ? (bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1) : lots_of_twos;
  1475.  
  1476.     for(i = 15; i >= 0; i--, data >>= 1, datb >>= 1) {
  1477.     int sprxpos = sprxp + i*(lores ? 1 : 2);
  1478.     int plno;
  1479.     int col;
  1480.  
  1481.     /* When doing the slow line update, the following condition can
  1482.      * happen. Lower-numbered sprites get the higher priority. */
  1483.     if (spixstate[sprxpos] & ((1 << num)-1))
  1484.         continue;
  1485.  
  1486.     /* Check the priority, but only if we did not already put a sprite
  1487.      * pixel at this position. If there's already a sprite pixel here, 
  1488.      * the priority was previously tested. */
  1489.     if (!spixstate[sprxpos]) {
  1490.         /* ??? What about hires mode when one hires pixel is 0, enabling the
  1491.          * sprite, and the other is != 0, blocking it? */
  1492.         plno = lookup_no[pixdata.apixels[sprxpos]];
  1493.         if (plno != 0 && (1 << num) >= plfpri[plno])
  1494.         continue;
  1495.     }
  1496.  
  1497.     if ((bpl_info.sprctl[num] & 0x80) && (num & 1)) {
  1498.         /* Attached sprite */
  1499.         col = ((data << 2) & 4) + ((datb << 3) & 8);
  1500.         spixstate[sprxpos] |= 1 << (num-1);
  1501.         spixels[sprxpos] = col;
  1502.     } else {            
  1503.         col = (data & 1) | ((datb << 1) & 2);
  1504.         if (spixstate[sprxpos] & (1 << num)) {
  1505.         /* Finish attached sprite */
  1506.         /* Did the upper half of the sprite have any bits set? */
  1507.         if (spixstate[sprxpos] & (1 << (num+1)))
  1508.             col += spixels[sprxpos];
  1509.         /* Is there any sprite pixel at this position at all? */
  1510.         if (!col) {
  1511.             spixstate[sprxpos] &= ~(3 << num);
  1512.         } else
  1513.             col += 16;
  1514.         } else {
  1515.         if (col) {
  1516.             col |= 16 | ((num & 6) << 1);
  1517.         }
  1518.         }
  1519.     }
  1520.     if (col) {
  1521.         pixdata.apixels[sprxpos] = col;
  1522.         spixstate[sprxpos] |= 1<<num;
  1523.         if (!lores) {
  1524.         pixdata.apixels[sprxpos+1] = col;
  1525.         spixstate[sprxpos+1] |= 1<<num;
  1526.         }
  1527.         if (bplham && bplplanecnt == 6) {
  1528.         ham_linebuf[sprxpos] = bpl_info.color_regs[col];
  1529.         if (!lores)
  1530.             ham_linebuf[sprxpos+1] = bpl_info.color_regs[col];
  1531.         }
  1532.     }
  1533.     }
  1534. }
  1535. #else /* AGA version */
  1536. static void pfield_sprite (int num, int sprxp, UWORD data, UWORD datb, int lores)
  1537. {
  1538.     int i;
  1539.  
  1540.     int *lookup = bpldualpf ? (bpldualpfpri ? dblpf_ind2 : dblpf_ind1) : linear_map_256;
  1541.     int *lookup_no = bpldualpf ? (bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1) : lots_of_twos;
  1542.  
  1543.     for(i = 15; i >= 0; i--, data >>= 1, datb >>= 1) {
  1544.     int sprxpos = sprxp + i*(lores ? 1 : 2);
  1545.     int plno;
  1546.     int col;
  1547.  
  1548.     /* When doing the slow line update, the following condition can
  1549.      * happen. Lower-numbered sprites get the higher priority. */
  1550.     if (spixstate[sprxpos] & ((1 << num)-1))
  1551.         continue;
  1552.  
  1553.     /* Check the priority, but only if we did not already put a sprite
  1554.      * pixel at this position. If there's already a sprite pixel here, 
  1555.      * the priority was previously tested. */
  1556.     if (!spixstate[sprxpos]) {
  1557.         /* ??? What about hires mode when one hires pixel is 0, enabling the
  1558.          * sprite, and the other is != 0, blocking it? */
  1559.         plno = lookup_no[pixdata.apixels[sprxpos]];
  1560.         if (plno != 0 && (1 << num) >= plfpri[plno])
  1561.         continue;
  1562.     }
  1563.  
  1564.     if ((bpl_info.sprctl[num] & 0x80) && (num & 1)) {
  1565.         /* Attached sprite */
  1566.         col = ((data << 2) & 4) + ((datb << 3) & 8);
  1567.         spixstate[sprxpos] |= 1 << (num-1);
  1568.         spixels[sprxpos] = col;
  1569.     } else {            
  1570.         col = (data & 1) | ((datb << 1) & 2);
  1571.         if (spixstate[sprxpos] & (1 << num)) {
  1572.         /* Finish attached sprite */
  1573.         /* Did the upper half of the sprite have any bits set? */
  1574.         if (spixstate[sprxpos] & (1 << (num+1)))
  1575.             col += spixels[sprxpos];
  1576.         /* Is there any sprite pixel at this position at all? */
  1577.         if (!col) {
  1578.             spixstate[sprxpos] &= ~(3 << num);
  1579.         } else
  1580.             col += ((bpl_info.bplcon4 << (num & 1 ? 4 : 0)) & 240);
  1581.         } else {
  1582.         if (col) {
  1583.             col |= ((bpl_info.bplcon4 << (num & 1 ? 4 : 0)) & 240) | ((num & 6) << 1);
  1584.         }
  1585.         }
  1586.     }
  1587.     if (col) {
  1588.         pixdata.apixels[sprxpos] = col;
  1589.         spixstate[sprxpos] |= 1<<num;
  1590.         if (!lores) {
  1591.         pixdata.apixels[sprxpos+1] = col;
  1592.         spixstate[sprxpos+1] |= 1<<num;
  1593.         }
  1594.         if (bplham && bplplanecnt == 6) {
  1595.         ham_linebuf[sprxpos] = bpl_info.color_regs[col];
  1596.         if (!lores)
  1597.             ham_linebuf[sprxpos+1] = bpl_info.color_regs[col];
  1598.         }
  1599.     }
  1600.     }
  1601. }
  1602. #endif
  1603.  
  1604. static __inline__ UBYTE *pfield_xlateptr(CPTR plpt, int bytecount)
  1605. {
  1606.     if (!chipmem_bank.check(plpt,bytecount)) {
  1607.     static int count = 0;
  1608.     if (count < 5) {
  1609.         count++;
  1610.         fprintf(stderr, "Warning: Bad playfield pointer");
  1611.         if (count == 5) fprintf(stderr, " (no further warnings)");
  1612.         fprintf(stderr, "\n");
  1613.     }
  1614.     return NULL;
  1615.     }
  1616.     return chipmem_bank.xlateaddr(plpt);
  1617. }
  1618.  
  1619. static void pfield_doline_slow_h(int currhpos)
  1620. {
  1621.     int xpos = currhpos * 4 - 0x60;
  1622.         
  1623.     if (bplhires) {
  1624.     int offs1 = xpos + 16 + bpldelay1*2;
  1625.     int offs2 = xpos + 16 + bpldelay2*2;
  1626.     
  1627.     int pix;
  1628.     for(pix = 15; pix >= 0; pix--) {
  1629.         switch(bplplanecnt) {
  1630.          case 8:
  1631.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1632.          case 7:
  1633.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1634.          case 6:
  1635.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1636.          case 5:
  1637.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1638.          case 4:
  1639.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1640.          case 3:
  1641.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1642.          case 2:
  1643.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1644.          case 1:
  1645.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1646.         }
  1647.     }
  1648.     } else {
  1649.     int offs1 = xpos + 32 + bpldelay1*2;
  1650.     int offs2 = xpos + 32 + bpldelay2*2;
  1651.     
  1652.     int pix;
  1653.     for(pix = 30; pix >= 0; pix -= 2) {
  1654.         switch(bplplanecnt) {
  1655.          case 8:
  1656.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80;
  1657.         pixdata.apixels[pix + offs2 + 1] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1658.          case 7:
  1659.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; 
  1660.         pixdata.apixels[pix + offs1 + 1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1661.          case 6:
  1662.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20;
  1663.         pixdata.apixels[pix + offs2 + 1] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1664.          case 5:
  1665.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10;
  1666.         pixdata.apixels[pix + offs1 + 1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1667.          case 4:
  1668.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8;
  1669.         pixdata.apixels[pix + offs2 + 1] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1670.          case 3:
  1671.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; 
  1672.         pixdata.apixels[pix + offs1 + 1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1673.          case 2:
  1674.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; 
  1675.         pixdata.apixels[pix + offs2 + 1] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1676.          case 1:
  1677.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; 
  1678.         pixdata.apixels[pix + offs1 + 1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1679.         }
  1680.     }
  1681.     }    
  1682. }
  1683.  
  1684. static void pfield_doline_slow_l(int currhpos)
  1685. {
  1686.     int xpos = currhpos * 2 - 0x30;
  1687.     
  1688.     if (bplhires) {
  1689.     int offs1 = xpos + 8 + bpldelay1;
  1690.     int offs2 = xpos + 8 + bpldelay2;
  1691.     
  1692.     int pix;
  1693.     for(pix = 7; pix >= 0; pix--) {
  1694.         switch(bplplanecnt) {
  1695.          case 8:
  1696.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 2;
  1697.          case 7:
  1698.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 2;
  1699.          case 6:
  1700.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 2;
  1701.          case 5:
  1702.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 2;
  1703.          case 4:
  1704.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 2;
  1705.          case 3:
  1706.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 2;
  1707.          case 2:
  1708.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 2;
  1709.          case 1:
  1710.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 2;
  1711.         }
  1712.     }
  1713.     } else {
  1714.     int offs1 = xpos + 16 + bpldelay1;
  1715.     int offs2 = xpos + 16 + bpldelay2;
  1716.     
  1717.     int pix;
  1718.     for(pix = 15; pix >= 0; pix --) {
  1719.         switch(bplplanecnt) {
  1720.          case 8:
  1721.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1722.          case 7:
  1723.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1724.          case 6:
  1725.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1726.          case 5:
  1727.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1728.          case 4:
  1729.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1730.          case 3:
  1731.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1732.          case 2:
  1733.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1734.          case 1:
  1735.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1736.         }
  1737.     }
  1738.     }    
  1739. }
  1740.  
  1741. ULONG hirestab_h[256][2];
  1742. ULONG lorestab_h[256][4];
  1743.  
  1744. ULONG hirestab_l[256][1];
  1745. ULONG lorestab_l[256][2];
  1746.  
  1747. static void gen_pfield_tables(void)
  1748. {
  1749.     int i;
  1750.     union {
  1751.     struct {
  1752.         UBYTE a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
  1753.     } foo;
  1754.     struct {
  1755.         ULONG a, b, c, d;
  1756.     } bar;
  1757.     } baz;
  1758.     
  1759.     for (i = 0; i < 256; i++) {
  1760.     /* We lose every second pixel in HiRes if UAE runs in a 320x200 screen. */
  1761.     baz.foo.a = i & 64 ? 1 : 0;
  1762.     baz.foo.b = i & 16 ? 1 : 0;
  1763.     baz.foo.c = i & 4 ? 1 : 0;
  1764.     baz.foo.d = i & 1 ? 1 : 0;
  1765.     hirestab_l[i][0] = baz.bar.a;
  1766.     
  1767.     baz.foo.a = i & 128 ? 1 : 0;
  1768.     baz.foo.b = i & 64 ? 1 : 0;
  1769.     baz.foo.c = i & 32 ? 1 : 0;
  1770.     baz.foo.d = i & 16 ? 1 : 0;
  1771.     baz.foo.e = i & 8 ? 1 : 0;
  1772.     baz.foo.f = i & 4 ? 1 : 0;
  1773.     baz.foo.g = i & 2 ? 1 : 0;
  1774.     baz.foo.h = i & 1 ? 1 : 0;
  1775.     lorestab_l[i][0] = baz.bar.a;
  1776.     lorestab_l[i][1] = baz.bar.b;
  1777.     }
  1778.     
  1779.     for (i = 0; i < 256; i++) {
  1780.     baz.foo.a = i & 128 ? 1 : 0;
  1781.     baz.foo.b = i & 64 ? 1 : 0;
  1782.     baz.foo.c = i & 32 ? 1 : 0;
  1783.     baz.foo.d = i & 16 ? 1 : 0;
  1784.     baz.foo.e = i & 8 ? 1 : 0;
  1785.     baz.foo.f = i & 4 ? 1 : 0;
  1786.     baz.foo.g = i & 2 ? 1 : 0;
  1787.     baz.foo.h = i & 1 ? 1 : 0;
  1788.     hirestab_h[i][0] = baz.bar.a;
  1789.     hirestab_h[i][1] = baz.bar.b;
  1790.     
  1791.     baz.foo.a = i & 128 ? 1 : 0;
  1792.     baz.foo.b = i & 128 ? 1 : 0;
  1793.     baz.foo.c = i & 64 ? 1 : 0;
  1794.     baz.foo.d = i & 64 ? 1 : 0;
  1795.     baz.foo.e = i & 32 ? 1 : 0;
  1796.     baz.foo.f = i & 32 ? 1 : 0;
  1797.     baz.foo.g = i & 16 ? 1 : 0;
  1798.     baz.foo.h = i & 16 ? 1 : 0;
  1799.     baz.foo.i = i & 8 ? 1 : 0;
  1800.     baz.foo.j = i & 8 ? 1 : 0;
  1801.     baz.foo.k = i & 4 ? 1 : 0;
  1802.     baz.foo.l = i & 4 ? 1 : 0;
  1803.     baz.foo.m = i & 2 ? 1 : 0;
  1804.     baz.foo.n = i & 2 ? 1 : 0;
  1805.     baz.foo.o = i & 1 ? 1 : 0;
  1806.     baz.foo.p = i & 1 ? 1 : 0;
  1807.     lorestab_h[i][0] = baz.bar.a;
  1808.     lorestab_h[i][1] = baz.bar.b;
  1809.     lorestab_h[i][2] = baz.bar.c;
  1810.     lorestab_h[i][3] = baz.bar.d;
  1811.     }
  1812. }
  1813.  
  1814. static __inline__ void pfield_orword_hires_h(int data, unsigned char *dp, int bit)
  1815. {
  1816.     ULONG *pixptr = (ULONG *)dp;
  1817.  
  1818.     *pixptr |= hirestab_h[data >> 8][0] << bit;
  1819.     *(pixptr+1) |= hirestab_h[data >> 8][1] << bit;
  1820.     *(pixptr+2) |= hirestab_h[data & 255][0] << bit;
  1821.     *(pixptr+3) |= hirestab_h[data & 255][1] << bit;
  1822. }
  1823.  
  1824. static __inline__ void pfield_orword_lores_h(int data, unsigned char *dp, int bit)
  1825. {
  1826.     ULONG *pixptr = (ULONG *)dp;
  1827.     
  1828.     *pixptr |= lorestab_h[data >> 8][0] << bit;
  1829.     *(pixptr+1) |= lorestab_h[data >> 8][1] << bit;
  1830.     *(pixptr+2) |= lorestab_h[data >> 8][2] << bit;
  1831.     *(pixptr+3) |= lorestab_h[data >> 8][3] << bit;
  1832.     *(pixptr+4) |= lorestab_h[data & 255][0] << bit;
  1833.     *(pixptr+5) |= lorestab_h[data & 255][1] << bit;
  1834.     *(pixptr+6) |= lorestab_h[data & 255][2] << bit;
  1835.     *(pixptr+7) |= lorestab_h[data & 255][3] << bit;
  1836. }
  1837.  
  1838. static __inline__ void pfield_setword_hires_h(int data, unsigned char *dp, int bit)
  1839. {
  1840.     ULONG *pixptr = (ULONG *)dp;
  1841.  
  1842.     *pixptr = hirestab_h[data >> 8][0] << bit;
  1843.     *(pixptr+1) = hirestab_h[data >> 8][1] << bit;
  1844.     *(pixptr+2) = hirestab_h[data & 255][0] << bit;
  1845.     *(pixptr+3) = hirestab_h[data & 255][1] << bit;
  1846. }
  1847.  
  1848. static __inline__ void pfield_setword_lores_h(int data, unsigned char *dp, int bit)
  1849. {
  1850.     ULONG *pixptr = (ULONG *)dp;
  1851.     
  1852.     *pixptr = lorestab_h[data >> 8][0] << bit;
  1853.     *(pixptr+1) = lorestab_h[data >> 8][1] << bit;
  1854.     *(pixptr+2) = lorestab_h[data >> 8][2] << bit;
  1855.     *(pixptr+3) = lorestab_h[data >> 8][3] << bit;
  1856.     *(pixptr+4) = lorestab_h[data & 255][0] << bit;
  1857.     *(pixptr+5) = lorestab_h[data & 255][1] << bit;
  1858.     *(pixptr+6) = lorestab_h[data & 255][2] << bit;
  1859.     *(pixptr+7) = lorestab_h[data & 255][3] << bit;
  1860. }
  1861.  
  1862. static __inline__ void pfield_orword_hires_l(int data, unsigned char *dp, int bit)
  1863. {
  1864.     ULONG *pixptr = (ULONG *)dp;
  1865.  
  1866.     *pixptr |= hirestab_l[data >> 8][0] << bit;
  1867.     *(pixptr+1) |= hirestab_l[data & 255][0] << bit;
  1868. }
  1869.  
  1870. static __inline__ void pfield_orword_lores_l(int data, unsigned char *dp, int bit)
  1871. {
  1872.     ULONG *pixptr = (ULONG *)dp;
  1873.     
  1874.     *pixptr |= lorestab_l[data >> 8][0] << bit;
  1875.     *(pixptr+1) |= lorestab_l[data >> 8][1] << bit;
  1876.     *(pixptr+2) |= lorestab_l[data & 255][0] << bit;
  1877.     *(pixptr+3) |= lorestab_l[data & 255][1] << bit;
  1878. }
  1879.  
  1880. static __inline__ void pfield_setword_hires_l(int data, unsigned char *dp, int bit)
  1881. {
  1882.     ULONG *pixptr = (ULONG *)dp;
  1883.  
  1884.     *pixptr = hirestab_l[data >> 8][0] << bit;
  1885.     *(pixptr+1) = hirestab_l[data & 255][0] << bit;
  1886. }
  1887.  
  1888. static __inline__ void pfield_setword_lores_l(int data, unsigned char *dp, int bit)
  1889. {
  1890.     ULONG *pixptr = (ULONG *)dp;
  1891.     
  1892.     *pixptr = lorestab_l[data >> 8][0] << bit;
  1893.     *(pixptr+1) = lorestab_l[data >> 8][1] << bit;
  1894.     *(pixptr+2) = lorestab_l[data & 255][0] << bit;
  1895.     *(pixptr+3) = lorestab_l[data & 255][1] << bit;
  1896. }
  1897.  
  1898. #define DO_ONE_PLANE(POINTER, MULT, FUNC, DELAY, LL_SUB, P_ADD) { \
  1899.     int i; \
  1900.     unsigned int bpldat1; \
  1901.     UWORD data; \
  1902.     unsigned int bpldat2 = 0; \
  1903.     for (i = plflinelen; i > 0; i -= LL_SUB) { \
  1904.         bpldat1 = bpldat2; \
  1905.     bpldat2 = (*POINTER << 8) | *(POINTER+1); \
  1906.         POINTER+=2; \
  1907.     data = (bpldat1 << (16 - DELAY)) | (bpldat2 >> DELAY); \
  1908.     FUNC(data, app, MULT); \
  1909.     app += P_ADD; \
  1910.     } \
  1911.     data = bpldat2 << (16 - DELAY); \
  1912.     FUNC(data, app, MULT); \
  1913. }
  1914.  
  1915. #if 1
  1916. static void pfield_doline_h(void)
  1917. {
  1918.     int xpos = plfstrt * 4 - 0x60;
  1919.     int spr, sprites_seen;
  1920.  
  1921.     if (bplhires) {
  1922.     if (bplplanecnt > 0) {
  1923.         int xpos1 = xpos + 16 + (bpldelay1 >= 8 ? 16 : 0);
  1924.         int xpos2 = xpos + 16 + (bpldelay2 >= 8 ? 16 : 0);
  1925.         int delay1 = 2*(bpldelay1 & 7);
  1926.         int delay2 = 2*(bpldelay2 & 7);
  1927.         unsigned char *app = pixdata.apixels + xpos1;
  1928.  
  1929.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_hires_h, delay1, 4, 16);
  1930.         if (bplplanecnt > 2) {
  1931.         app = pixdata.apixels + xpos1;
  1932.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_hires_h, delay1, 4, 16);
  1933.         }
  1934. #if AGA_CHIPSET == 1
  1935.         if (bplplanecnt > 4) {
  1936.         app = pixdata.apixels + xpos1;
  1937.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_hires_h, delay1, 4, 16);
  1938.         }
  1939.         if (bplplanecnt > 6) {
  1940.         app = pixdata.apixels + xpos1;
  1941.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_hires_h, delay1, 4, 16);
  1942.         }
  1943. #endif
  1944.         if (bplplanecnt > 1) {
  1945.         app = pixdata.apixels + xpos2;
  1946.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_hires_h, delay2, 4, 16);
  1947.         }
  1948.         if (bplplanecnt > 3) {
  1949.         app = pixdata.apixels + xpos2;
  1950.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_hires_h, delay2, 4, 16);
  1951.         }
  1952. #if AGA_CHIPSET == 1
  1953.         if (bplplanecnt > 5) {
  1954.         app = pixdata.apixels + xpos2;
  1955.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_hires_h, delay2, 4, 16);
  1956.         }
  1957.         if (bplplanecnt > 7) {
  1958.         app = pixdata.apixels + xpos2;
  1959.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_hires_h, delay2, 4, 16);
  1960.         }
  1961. #endif
  1962.     } else {
  1963.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  1964.     }
  1965.     } else {
  1966.     if (bplplanecnt > 0) {
  1967.         int x = xpos + 32;
  1968.         unsigned char *app = pixdata.apixels + x;
  1969.         
  1970.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_lores_h, bpldelay1, 8, 32);
  1971.         if (bplplanecnt > 2) {
  1972.         app = pixdata.apixels + x;
  1973.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_lores_h, bpldelay1, 8, 32);
  1974.         }
  1975.         if (bplplanecnt > 4) {
  1976.         app = pixdata.apixels + x;
  1977.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_lores_h, bpldelay1, 8, 32);
  1978.         }
  1979. #if AGA_CHIPSET == 1
  1980.         if (bplplanecnt > 6) {
  1981.         app = pixdata.apixels + x;
  1982.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_lores_h, bpldelay1, 8, 32);
  1983.         }
  1984. #endif
  1985.         if (bplplanecnt > 1) {
  1986.         app = pixdata.apixels + x;
  1987.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_lores_h, bpldelay2, 8, 32);
  1988.         }
  1989.         if (bplplanecnt > 3) {
  1990.         app = pixdata.apixels + x;
  1991.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_lores_h, bpldelay2, 8, 32);
  1992.         }
  1993.         if (bplplanecnt > 5) {
  1994.         app = pixdata.apixels + x;
  1995.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_lores_h, bpldelay2, 8, 32);
  1996.         }
  1997. #if AGA_CHIPSET == 1
  1998.         if (bplplanecnt > 7) {
  1999.         app = pixdata.apixels + x;
  2000.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_lores_h, bpldelay2, 8, 32);
  2001.         }
  2002. #endif
  2003.     } else {
  2004.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2005.     }
  2006.     }
  2007.     
  2008.     decode_ham6 (16,812);
  2009.         
  2010.     linetoscreen = 1;
  2011.     sprites_seen = 0;
  2012.     
  2013.     for(spr = 7; spr >= 0; spr--) {
  2014.     if (bpl_info.sprarmed[spr]) {
  2015.         int sprxp = ((bpl_info.sprpos[spr] & 0xFF) * 4) - 0x60 + (bpl_info.sprctl[spr] & 1)*2;
  2016.         int i;
  2017.         /* Ugh. Nasty bug. Let's rather lose some sprites than trash
  2018.          * memory. */
  2019.         if (sprxp >= 0) {
  2020.         if (!sprites_seen) {
  2021.             sprites_seen = 1;
  2022.             memset(spixstate,0,sizeof spixstate);
  2023.         }
  2024.         pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], 0);
  2025.         }
  2026.     }
  2027.     }
  2028. }
  2029. #endif
  2030. static void pfield_doline_l(void)
  2031. {
  2032.     int xpos = plfstrt * 2 - 0x30;
  2033.     int spr;
  2034.     int sprites_seen;
  2035.         
  2036.     if (bplhires) {
  2037.     if (bplplanecnt > 0) {
  2038.         int xpos1 = xpos + 8 + (bpldelay1 >= 8 ? 8 : 0);
  2039.         int xpos2 = xpos + 8 + (bpldelay2 >= 8 ? 8 : 0);
  2040.         int delay1 = (bpldelay1 & 7) * 2;
  2041.         int delay2 = (bpldelay2 & 7) * 2;
  2042.         unsigned char *app = pixdata.apixels + xpos1;
  2043.         
  2044.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_hires_l, delay1, 4, 8);
  2045.         if (bplplanecnt > 2) {
  2046.         app = pixdata.apixels + xpos1;
  2047.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_hires_l, delay1, 4, 8);
  2048.         }
  2049. #if AGA_CHIPSET == 1
  2050.         if (bplplanecnt > 4) {
  2051.         app = pixdata.apixels + xpos1;
  2052.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_hires_l, delay1, 4, 8);
  2053.         }
  2054.         if (bplplanecnt > 6) {
  2055.         app = pixdata.apixels + xpos1;
  2056.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_hires_l, delay1, 4, 8);
  2057.         }
  2058. #endif
  2059.         if (bplplanecnt > 1) {
  2060.         app = pixdata.apixels + xpos2;
  2061.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_hires_l, delay2, 4, 8);
  2062.         }
  2063.         if (bplplanecnt > 3) {
  2064.         app = pixdata.apixels + xpos2;
  2065.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_hires_l, delay2, 4, 8);
  2066.         }
  2067. #if AGA_CHIPSET == 1
  2068.         if (bplplanecnt > 5) {
  2069.         app = pixdata.apixels + xpos2;
  2070.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_hires_l, delay2, 4, 8);
  2071.         }
  2072.         if (bplplanecnt > 7) {
  2073.         app = pixdata.apixels + xpos2;
  2074.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_hires_l, delay2, 4, 8);
  2075.         }
  2076. #endif
  2077.     } else {
  2078.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2079.     }
  2080.     } else {
  2081.     if (bplplanecnt > 0) {
  2082.         int x = xpos + 16;
  2083.         int delay1 = bpldelay1;
  2084.         int delay2 = bpldelay2;
  2085.         unsigned char *app = pixdata.apixels + x;
  2086.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_lores_l, delay1, 8, 16);
  2087.         if (bplplanecnt > 2) {
  2088.         app = pixdata.apixels + x;
  2089.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_lores_l, delay1, 8, 16);
  2090.         }
  2091.         if (bplplanecnt > 4) {
  2092.         app = pixdata.apixels + x;
  2093.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_lores_l, delay1, 8, 16);
  2094.         }
  2095. #if AGA_CHIPSET == 1
  2096.         if (bplplanecnt > 6) {
  2097.         app = pixdata.apixels + x;
  2098.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_lores_l, delay1, 8, 16);
  2099.         }
  2100. #endif
  2101.         if (bplplanecnt > 1) {
  2102.         app = pixdata.apixels + x;
  2103.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_lores_l, delay2, 8, 16);
  2104.         }
  2105.         if (bplplanecnt > 3) {
  2106.         app = pixdata.apixels + x;
  2107.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_lores_l, delay2, 8, 16);
  2108.         }
  2109.         if (bplplanecnt > 5) {
  2110.         app = pixdata.apixels + x;
  2111.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_lores_l, delay2, 8, 16);
  2112.         }
  2113. #if AGA_CHIPSET == 1
  2114.         if (bplplanecnt > 7) {
  2115.         app = pixdata.apixels + x;
  2116.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_lores_l, delay2, 8, 16);
  2117.         }
  2118. #endif
  2119.     } else {
  2120.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2121.     }
  2122.     }
  2123.  
  2124.     decode_ham6 (8,406);
  2125.  
  2126.     linetoscreen = 1;
  2127.     sprites_seen = 0;
  2128.  
  2129.     for(spr = 7; spr >= 0; spr--) {
  2130.     if (bpl_info.sprarmed[spr]) {
  2131.         int sprxp = ((bpl_info.sprpos[spr] & 0xFF) * 2) - 0x30 + (bpl_info.sprctl[spr] & 1);
  2132.         int i;
  2133.         /* Ugh. Nasty bug. Let's rather lose some sprites than trash
  2134.          * memory. */
  2135.         if (sprxp >= 0) {
  2136.         if (!sprites_seen) {
  2137.             sprites_seen = 1;
  2138.             memset(spixstate,0,sizeof spixstate);
  2139.         }
  2140.             pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], 1);
  2141.         }
  2142.     }
  2143.     }
  2144. }
  2145.  
  2146. static int bpl_data_differs(UBYTE *data, UBYTE *r_addr, int nbytes)
  2147. {
  2148.     return memcmpy(data, r_addr, nbytes);
  2149. }
  2150.  
  2151. static __inline__ int bplinfo_differs(struct bplinfo *a, struct bplinfo *b)
  2152. {
  2153.     int ncolors;
  2154.     int i;
  2155.     if (a->bplcon0 != b->bplcon0
  2156.     || a->bplcon1 != b->bplcon1
  2157.     || a->bplcon2 != b->bplcon2
  2158.     || a->bplcon3 != b->bplcon3
  2159.     || a->bplcon4 != b->bplcon4
  2160.     || a->diwstrt != b->diwstrt
  2161.     || a->diwstop != b->diwstop
  2162.     || a->ddfstrt != b->ddfstrt
  2163.     || a->ddfstop != b->ddfstop)
  2164.     return 1;
  2165.  
  2166. #if 1
  2167.     /* This sometimes loses for sprite colors */
  2168.     ncolors = 1 << ((a->bplcon0 & 0x7000) >> 12);
  2169.     if (ncolors == 64)
  2170.     ncolors = (a->bplcon0 & 0x800) ? 16 : 32;
  2171.     for (i = 0; i < ncolors; i++)
  2172.     if (a->color_regs[i] != b->color_regs[i])
  2173.         return 1;
  2174. #else
  2175.     /* ... and this will lose badly on few-color screens when we implement 
  2176.      * AGA.
  2177.      */
  2178.     if (memcmp(a->color_regs, b->color_regs, sizeof a->color_regs) != 0)
  2179.     return 1;
  2180. #endif
  2181.     for (i = 0; i < 8; i++) {
  2182.     if (a->sprarmed[i] != b->sprarmed[i])
  2183.         return 1;
  2184.     if (a->sprarmed[i]
  2185.         && (a->sprctl[i] != b->sprctl[i]
  2186.         || a->sprpos[i] != b->sprpos[i]
  2187.         || a->sprdata[i] != b->sprdata[i]
  2188.         || a->sprdatb[i] != b->sprdatb[i]))
  2189.         return 1;
  2190.     }
  2191.     return 0;
  2192. }
  2193.  
  2194. static void pfield_doline(void)
  2195. {
  2196.     int bytecount = plflinelen / (bplhires ? 4 : 8) * 2;
  2197.     int drawit = 0;
  2198.     int i;
  2199.     
  2200.     if (vpos < plffirstline || vpos >= plflastline) 
  2201.         return;
  2202.  
  2203.     if (!dmaen(0x100) || !pfield_linedmaon) {
  2204.     line_in_border = 1;
  2205.     return;
  2206.     }
  2207.     
  2208.     for (i = 0; i < bplplanecnt; i++) {
  2209.     r_bplpt[i] = pfield_xlateptr(bplpt[i], bytecount);
  2210.     if (r_bplpt[i] == NULL)
  2211.         return;
  2212.     }
  2213.     
  2214. #if SMART_UPDATE == 1
  2215.     drawit = bplinfo_differs(&bpl_info, &linedescr[next_lineno].bpl_info);
  2216.     if (drawit) {
  2217.     linedescr[next_lineno].bpl_info = bpl_info;
  2218.     }
  2219.     drawit |= !linedescr[next_lineno].linedata_valid | frame_redraw_necessary;
  2220.     
  2221.     if (bytecount <= MAX_WORDS_PER_LINE * 2) {
  2222.     linedescr[next_lineno].linedata_valid = 1;
  2223.     for (i = 0; i < bplplanecnt; i++)
  2224.         drawit |= bpl_data_differs(line_data[next_lineno][i],r_bplpt[i],
  2225.                        bytecount);
  2226.     
  2227.     } else {
  2228.     linedescr[next_lineno].linedata_valid = 0;
  2229.     }
  2230. #endif
  2231.  
  2232.     pfield_modulos(bytecount);
  2233.  
  2234. #if SMART_UPDATE != 0
  2235.     if (!drawit)
  2236.     return;
  2237. #endif    
  2238.  
  2239.     if (use_lores)
  2240.     pfield_doline_l();
  2241.     else
  2242.     pfield_doline_h();
  2243. }
  2244.  
  2245. static void pfield_doline_slow(int currhp)
  2246. {
  2247.     int xpos = PIXEL_XPOS(currhp);
  2248.  
  2249.     if (vpos < plffirstline || vpos >= plflastline) 
  2250.         return;
  2251.     
  2252.     if (currhp == plfstrt)
  2253.     slowline_nextpos = currhp;
  2254.  
  2255.     if (currhp == slowline_nextpos) {    
  2256.     if (slowline_linepos >= plflinelen) {
  2257.         /* The modulos must get added at exactly this point. */
  2258.         pfield_modulos(0);
  2259.         slowline_nextpos = -1;
  2260.     } else {
  2261.         slowline_nextpos += bplhires ? 4 : 8;
  2262.         slowline_linepos += bplhires ? 4 : 8;
  2263.  
  2264.         /* Hmmmm.....
  2265.          * In theory, we could use the fast pfield_doline functions even
  2266.          * in this case. We only need to do sprites, ham decoding and
  2267.          * the line_to_scr stuff cycle-per-cycle. However, we would no
  2268.          * longer be able to emulate tricks that switch lores/hires in
  2269.          * the middle of a line, but I'm not sure whether this sort of
  2270.          * thing actually works currently and whether it's worthwhile.
  2271.          */
  2272.                      
  2273.         pfield_fetchdata();
  2274.  
  2275.         if (use_lores)
  2276.         pfield_doline_slow_l (currhp);
  2277.         else
  2278.         pfield_doline_slow_h (currhp);
  2279.         /* @@@ need to test this */
  2280.         decode_ham6 (xpos, PIXEL_XPOS(slowline_nextpos));
  2281.     }
  2282.     }
  2283.     if (currhp > 48) {
  2284.     int spr;
  2285.     for(spr = 7; spr >= 0; spr--) {
  2286.         if (bpl_info.sprarmed[spr] && currhp == (bpl_info.sprpos[spr] & 0xFF)) {
  2287.         int sprxp = xpos + (bpl_info.sprctl[spr] & 1) * (use_lores ? 1 : 2);
  2288.         pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], use_lores);
  2289.         }
  2290.     }
  2291.     }    
  2292. }
  2293.  
  2294. static int first_drawn_line, last_drawn_line;
  2295. static int first_block_line, last_block_line;
  2296.  
  2297. static void init_frame (void)
  2298. {
  2299.     int i;
  2300.     int maxpos = use_lores ? 400 : 800;
  2301.     int old_pmds = prev_max_diwstop;
  2302.     
  2303.     if (max_diwstop == 0)
  2304.     max_diwstop = diwlastword;
  2305.     
  2306.     if (max_diwstop < (use_lores ? 320 : 640) || max_diwstop > maxpos)
  2307.     prev_max_diwstop = maxpos;
  2308.     else
  2309.     prev_max_diwstop = max_diwstop;
  2310.  
  2311.     max_diwstop = 0;
  2312.  
  2313.     memset(spron, 0, sizeof spron);
  2314.     memset(bpl_info.sprpos, 0, sizeof bpl_info.sprpos);
  2315.     memset(bpl_info.sprctl, 0, sizeof bpl_info.sprctl);
  2316.     last_drawn_line = 0;
  2317.     first_drawn_line = 32767;
  2318.  
  2319.     first_block_line = last_block_line = -2;
  2320.     calc_adjustment();
  2321.     if (frame_redraw_necessary)
  2322.     frame_redraw_necessary--;
  2323.     
  2324.     if (old_pmds != prev_max_diwstop) {
  2325.     frame_redraw_necessary |= (bpl_info.bplcon0 & 4 ? 2 : 1);
  2326.     }
  2327. }
  2328.  
  2329. /*
  2330.  * A raster line has been built in the graphics buffer. Tell the graphics code
  2331.  * to do anything necessary to display it.
  2332.  */
  2333.  
  2334. static void do_flush_line (int lineno)
  2335. {
  2336.     if (lineno < first_drawn_line)
  2337.     first_drawn_line = lineno;
  2338.     if (lineno > last_drawn_line)
  2339.     last_drawn_line = lineno;
  2340.  
  2341.     if (gfxvidinfo.maxblocklines == 0)
  2342.     flush_line(lineno);
  2343.     else {
  2344.     if ((last_block_line+1) != lineno) {
  2345.         if (first_block_line != -2)
  2346.         flush_block (first_block_line, last_block_line);
  2347.         first_block_line = lineno;
  2348.     }
  2349.     last_block_line = lineno;
  2350.     if (last_block_line - first_block_line >= gfxvidinfo.maxblocklines) {
  2351.         flush_block (first_block_line, last_block_line);
  2352.         first_block_line = last_block_line = -2;
  2353.     }
  2354.     }
  2355. }
  2356.  
  2357. /*
  2358.  * One Amiga frame has been finished. Tell the graphics code about it.
  2359.  * Note that the actual flush_scren() call is a no-op for all reasonable
  2360.  * systems.
  2361.  */
  2362.  
  2363. static void do_flush_screen (int start, int stop)
  2364. {
  2365.     if (gfxvidinfo.maxblocklines != 0 && first_block_line != -2) {
  2366.     flush_block (first_block_line, last_block_line);
  2367.     }
  2368.     if (start <= stop)
  2369.     flush_screen (start, stop);
  2370. }
  2371.  
  2372. static void setdontcare(void)
  2373. {
  2374.     fprintf(stderr, "Don't care mouse mode set\n");
  2375.     mousestate = dont_care_mouse;
  2376.     lastspr0x = lastmx; lastspr0y = lastmy;
  2377.     mstepx = defstepx; mstepy = defstepy;
  2378. }
  2379.  
  2380. static void setfollow(void)
  2381. {
  2382.     fprintf(stderr, "Follow sprite mode set\n");
  2383.     mousestate = follow_mouse;
  2384.     lastdiffx = lastdiffy = 0;
  2385.     sprvbfl = 0;
  2386.     spr0ctl=spr0pos = 0;
  2387.     mstepx = defstepx; mstepy = defstepy;
  2388. }
  2389.  
  2390. void togglemouse(void)
  2391. {
  2392.     switch(mousestate) {
  2393.      case dont_care_mouse: setfollow(); break;
  2394.      case follow_mouse: setdontcare(); break;
  2395.      default: break; /* Nnnnnghh! */
  2396.     }
  2397. }        
  2398.  
  2399. static __inline__ int adjust(int val)
  2400. {
  2401.     if (val>127)
  2402.     return 127; 
  2403.     else if (val<-127)
  2404.     return -127;
  2405.     return val;
  2406. }
  2407.  
  2408. static void do_mouse_hack(void)
  2409. {
  2410.     int spr0x = ((spr0pos & 0xff) << 2) | ((spr0ctl & 1) << 1);
  2411.     int spr0y = ((spr0pos >> 8) | ((spr0ctl & 4) << 6)) << 1;
  2412.     int diffx, diffy;
  2413.     
  2414.     switch (mousestate) {
  2415.      case normal_mouse:
  2416.     diffx = lastmx - lastsampledmx;
  2417.     diffy = lastmy - lastsampledmy;
  2418.     if (!newmousecounters) {    
  2419.         if (diffx > 127) diffx = 127;
  2420.         if (diffx < -127) diffx = -127;
  2421.         joy0x += diffx;
  2422.         if (diffy > 127) diffy = 127;
  2423.         if (diffy < -127) diffy = -127;
  2424.         joy0y += diffy;
  2425.     }
  2426.     lastsampledmx += diffx; lastsampledmy += diffy;
  2427.     break;
  2428.  
  2429.      case dont_care_mouse:
  2430.     diffx = adjust (((lastmx-lastspr0x) * mstepx) >> 16);
  2431.     diffy = adjust (((lastmy-lastspr0y) * mstepy) >> 16);
  2432.     lastspr0x=lastmx; lastspr0y=lastmy;
  2433.     joy0x+=diffx; joy0y+=diffy;
  2434.     break;
  2435.     
  2436.      case follow_mouse:
  2437.     if (sprvbfl && sprvbfl-- >1) {
  2438.         int mousexpos, mouseypos;
  2439.         
  2440.         if ((lastdiffx > docal || lastdiffx < -docal) && lastspr0x != spr0x 
  2441.         && spr0x > plfstrt*4 + 34 + xcaloff && spr0x < plfstop*4 - xcaloff)
  2442.         {  
  2443.         int val = (lastdiffx << 16) / (spr0x - lastspr0x);
  2444.         if (val>=0x8000) mstepx=(mstepx*(calweight-1)+val)/calweight;
  2445.         }
  2446.         if ((lastdiffy > docal || lastdiffy < -docal) && lastspr0y != spr0y
  2447.         && spr0y>plffirstline+ycaloff && spr0y<plflastline-ycaloff) 
  2448.         { 
  2449.         int val = (lastdiffy<<16) / (spr0y-lastspr0y);
  2450.         if (val>=0x8000) mstepy=(mstepy*(calweight-1)+val)/calweight;
  2451.         }
  2452.         mousexpos = lastmx;
  2453.         if (gfxvidinfo.x_adjust)
  2454.         mousexpos += gfxvidinfo.x_adjust;
  2455.         mouseypos = lastmy;
  2456.         
  2457.         if(!correct_aspect)
  2458.             mouseypos *= 2;
  2459.         if(use_lores)
  2460.             mousexpos *= 2;
  2461.         if (gfxvidinfo.x_adjust)
  2462.         mousexpos -= 16;
  2463.  
  2464.         diffx = adjust ((((mousexpos + 0x70 + xoffs - spr0x) & ~1) * mstepx) >> 16);
  2465.         diffy = adjust ((((mouseypos + yoffs - spr0y+minfirstline*2) & ~1) * mstepy) >> 16);
  2466.         lastspr0x=spr0x; lastspr0y=spr0y;
  2467.         lastdiffx=diffx; lastdiffy=diffy;
  2468.         joy0x+=diffx; joy0y+=diffy; 
  2469.     }
  2470.     break;
  2471.     }
  2472. }
  2473.  
  2474. static void vsync_handler(void)
  2475. {
  2476.     UWORD dir;
  2477.     int button;
  2478.  
  2479.     handle_events();
  2480.     getjoystate(&joy0dir, &joy0button);
  2481.  
  2482.     do_mouse_hack();
  2483.     
  2484.     INTREQ(0x8020);
  2485.     if (bpl_info.bplcon0 & 4) lof ^= 0x8000;
  2486.     COPJMP1(0);
  2487.     
  2488.     if (framecnt == 0)
  2489.         do_flush_screen (first_drawn_line, last_drawn_line);
  2490.  
  2491.     count_frame();
  2492.     init_frame();
  2493. #ifdef HAVE_GETTIMEOFDAY
  2494.     {
  2495.     struct timeval tv;
  2496.     unsigned long int newtime;
  2497.     
  2498.     gettimeofday(&tv,NULL);    
  2499.     newtime = (tv.tv_sec-seconds_base) * 1000 + tv.tv_usec / 1000;
  2500.     
  2501.     if (!bogusframe) {    
  2502.         frametime += newtime - msecs;
  2503.         timeframes++;
  2504.     }
  2505.     msecs = newtime;
  2506.     bogusframe = 0;
  2507.     }
  2508. #endif
  2509.     CIA_vsync_handler();
  2510. }
  2511.  
  2512. static void hsync_handler(void)
  2513. {
  2514.     int lineno = vpos - minfirstline;
  2515.     int lineisdouble = 0;
  2516.     int line_was_doubled = 0;
  2517.     
  2518.     do_sprites(vpos, maxhpos);
  2519.     last_sprite = 0;
  2520.     
  2521.     if (correct_aspect) {
  2522.     lineno *= 2;
  2523.     if (bpl_info.bplcon0 & 4) {
  2524.         if(!lof) {
  2525.         lineno++;
  2526.         }
  2527.     } else {
  2528.         lineisdouble = 1;
  2529.     }
  2530.     }
  2531.  
  2532.     eventtab[ev_hsync].evtime += cycles - eventtab[ev_hsync].oldcycles;
  2533.     eventtab[ev_hsync].oldcycles = cycles;
  2534.     CIA_hsync_handler();
  2535.     
  2536.     if (produce_sound > 0) {
  2537.     int nr;
  2538.     /* Sound data is fetched at the beginning of each line */
  2539.     for (nr = 0; nr < 4; nr++) {
  2540.         struct audio_channel_data *cdp = audio_channel + nr;
  2541.         
  2542.         if (cdp->data_written == 2) {
  2543.         cdp->data_written = 0;
  2544.         cdp->nextdat = chipmem_bank.wget(cdp->pt);
  2545.         cdp->pt += 2;
  2546.         if (cdp->state == 2 || cdp->state == 3) {
  2547.             if (cdp->wlen == 1) {
  2548.             cdp->pt = cdp->lc;
  2549.             cdp->wlen = cdp->len;
  2550.             cdp->intreq2 = 1;
  2551.             } else
  2552.             cdp->wlen--;
  2553.         }
  2554.         }
  2555.     }
  2556.     }
  2557.  
  2558.     if (framecnt == 0 && vpos >= minfirstline && lineno < gfxvidinfo.maxline) {
  2559.     if (vpos >= plffirstline && vpos < plflastline)
  2560.     {
  2561.         /* Finish the line, if we started doing it with the slow update.
  2562.          * Otherwise, draw it entirely. */
  2563.         if (pfield_fullline) {        
  2564.         if (!pfield_linedone) {
  2565.             /* This can turn on line_in_border if DMA is off */
  2566.             pfield_doline();
  2567.         }
  2568.         if (linetoscreen)
  2569.             pfield_do_linetoscr_full (line_was_doubled = lineisdouble);
  2570.         } else {
  2571.         int i;
  2572.         for(i = pfield_lastpart_hpos; i < maxhpos; i++)
  2573.             pfield_doline_slow(i);
  2574.         pfield_do_linetoscr(slowline_lasttoscr, maxhpos);
  2575.         /* The COLOR routine masks off the high nibble. This means
  2576.          * that there will never be 0xFFFF in color_regs[0], and this
  2577.          * means that the line will be drawn completely the next time
  2578.          * we get into pfield_doline()
  2579.          */
  2580.         linedescr[lineno].bpl_info.color_regs[0] = 0xFFFF;
  2581.         linetoscreen = 1;
  2582.         }
  2583.     } else
  2584.         line_in_border = 1;
  2585.     
  2586.     if (line_in_border && 
  2587.         (!linedescr[lineno].inborder 
  2588.          || linedescr[lineno].bordercol != acolors[0]))
  2589.     {
  2590.         linedescr[lineno].bordercol = acolors[0];
  2591.         linedescr[lineno].linedata_valid = 0;
  2592.         
  2593.         fill_line (lineno);
  2594.         linetoscreen = 1;
  2595.     }
  2596.         
  2597.     linedescr[lineno].inborder = line_in_border;
  2598.     
  2599.     if (linetoscreen) {
  2600. #if AGA_CHIPSET == 1
  2601.         switch (gfxvidinfo.pixbytes) {
  2602.          case 1: aga_translate8 (0, aga_lbufptr-aga_linebuf); break;
  2603.          case 2: aga_translate16 (0, aga_lbufptr-aga_linebuf); break;
  2604.          case 4: aga_translate32 (0, aga_lbufptr-aga_linebuf); break;
  2605.         }
  2606. #endif
  2607.         do_flush_line (lineno);
  2608.     }
  2609.     if (lineisdouble) {
  2610.         int drawit = 0;
  2611.         
  2612.         if (linedescr[lineno].inborder != linedescr[lineno+1].inborder
  2613.         || (linedescr[lineno].inborder == 1
  2614.             && linedescr[lineno].bordercol != linedescr[lineno+1].bordercol)) {
  2615.         drawit = 1;
  2616.         
  2617.         } else if (linedescr[lineno].inborder == 0 
  2618.                && (linetoscreen 
  2619.                || (bplinfo_differs(&linedescr[lineno].bpl_info, 
  2620.                            &linedescr[lineno+1].bpl_info)))) {
  2621.         drawit = 1;
  2622.         }
  2623.         
  2624.         if (drawit) {
  2625.         linedescr[lineno+1].inborder = linedescr[lineno].inborder;
  2626.         linedescr[lineno+1].bordercol = linedescr[lineno].bordercol;
  2627. #if SMART_UPDATE != 0
  2628.         linedescr[lineno+1].bpl_info = linedescr[lineno].bpl_info;
  2629. #endif
  2630.         if (!line_was_doubled) {
  2631.             if (line_in_border)
  2632.             fill_line (lineno+1);
  2633.             else
  2634.             memcpy (gfxvidinfo.bufmem + (lineno+1)*gfxvidinfo.rowbytes,
  2635.                 gfxvidinfo.bufmem + lineno*gfxvidinfo.rowbytes,
  2636.                 gfxvidinfo.rowbytes);
  2637.         }
  2638.         do_flush_line (lineno+1);
  2639.         }
  2640.     }
  2641.     }
  2642.  
  2643.     pfield_calclinedma();
  2644.  
  2645.     if (++vpos == (maxvpos + (lof != 0))) {
  2646.     vpos = 0;
  2647.     vsync_handler();
  2648.     }
  2649.     
  2650.     if (framecnt == 0) 
  2651.     {
  2652.     lineno = vpos - minfirstline;
  2653.     
  2654.     if (correct_aspect) {
  2655.         lineno *= 2;
  2656.         if ((bpl_info.bplcon0 & 4) && !lof) {
  2657.         lineno++;
  2658.         }
  2659.     }
  2660.     xlinebuffer = gfxvidinfo.bufmem + gfxvidinfo.rowbytes * lineno;
  2661.     aga_lbufptr = aga_linebuf;
  2662.     next_lineno = lineno;
  2663.     linetoscreen = 0;
  2664.     line_in_border = 0;
  2665.     pfield_fullline = 1;
  2666.     pfield_linedone = 0;
  2667.     pfield_lastpart_hpos = 0;
  2668.     }
  2669.  
  2670. }
  2671.  
  2672. void customreset(void)
  2673. {
  2674.     int i;
  2675. #ifdef HAVE_GETTIMEOFDAY
  2676.     struct timeval tv;
  2677. #endif
  2678.     inhibit_frame = 0;
  2679.     expamem_reset();
  2680.     CIA_reset();
  2681.     cycles = 0; 
  2682.     regs.spcflags &= SPCFLAG_BRK;
  2683.     
  2684.     last_sprite = 0;
  2685.     vpos = 0; 
  2686.     lof = 0;
  2687.     next_lineno = 0;
  2688.     max_diwstop = 0;
  2689.     
  2690.     if (needmousehack()) {
  2691.         if (mousestate != follow_mouse) setfollow();
  2692.     } else {
  2693.     mousestate = normal_mouse;
  2694.     }
  2695.  
  2696.     memset(spixstate, 0, sizeof(spixstate));
  2697.     
  2698.     /*memset(blitcount, 0, sizeof(blitcount));  blitter debug */
  2699.     
  2700.     for (i = 0; i < numscrlines*2; i++) {
  2701.     linedescr[i].mnn = NULL;
  2702.     linedescr[i].linedata_valid = 0;
  2703.     linedescr[i].bpl_info.color_regs[0] = 0xFFFF;
  2704.     linedescr[i].bplpt[0] = (CPTR)-1;
  2705.     }
  2706.     
  2707.     xlinebuffer = gfxvidinfo.bufmem;
  2708.  
  2709.     dmacon = intena = 0;
  2710.     bltstate = BLT_done;
  2711.     copstate = COP_stop;
  2712.     copcon = 0;
  2713.     dskdmaen = 0;
  2714.     cycles = 0;
  2715.     
  2716.     memset(audio_channel, 0, sizeof audio_channel);
  2717.  
  2718.     bpl_info.bplcon4 = 0x11; /* Get AGA chipset into ECS compatibility mode */
  2719.     bpl_info.bplcon3 = 0xC00;
  2720.     for(i = 0; i < ev_max; i++) {
  2721.     eventtab[i].active = 0;
  2722.     eventtab[i].oldcycles = 0;
  2723.     }
  2724.     copper_active = 0;
  2725.     eventtab[ev_cia].handler = CIA_handler;
  2726.     eventtab[ev_copper].handler = do_copper;
  2727.     eventtab[ev_hsync].handler = hsync_handler;
  2728.     eventtab[ev_hsync].evtime = maxhpos + cycles;
  2729.     eventtab[ev_hsync].active = 1;
  2730.  
  2731.     eventtab[ev_blitter].handler = blitter_handler;
  2732.     eventtab[ev_blitter].active = 0;
  2733.     eventtab[ev_diskblk].handler = diskblk_handler;
  2734.     eventtab[ev_diskblk].active = 0;
  2735.     eventtab[ev_diskindex].handler = diskindex_handler;
  2736.     eventtab[ev_diskindex].active = 0;
  2737. #ifndef DONT_WANT_SOUND
  2738.     eventtab[ev_aud0].handler = aud0_handler;
  2739.     eventtab[ev_aud0].active = 0;
  2740.     eventtab[ev_aud1].handler = aud1_handler;
  2741.     eventtab[ev_aud1].active = 0;
  2742.     eventtab[ev_aud2].handler = aud2_handler;
  2743.     eventtab[ev_aud2].active = 0;
  2744.     eventtab[ev_aud3].handler = aud3_handler;
  2745.     eventtab[ev_aud3].active = 0;
  2746.     if (sound_available) {
  2747.     eventtab[ev_sample].active = 1;
  2748.     eventtab[ev_sample].evtime += cycles;
  2749.     eventtab[ev_sample].oldcycles = cycles;
  2750.     } else {
  2751.     eventtab[ev_sample].active = 0;
  2752.     }
  2753. #endif
  2754.     events_schedule();
  2755.     
  2756.     init_frame();
  2757. #ifdef HAVE_GETTIMEOFDAY
  2758.     gettimeofday(&tv,NULL);
  2759.     seconds_base = tv.tv_sec;
  2760.     bogusframe = 1;
  2761. #endif
  2762. }
  2763.  
  2764. void dumpcustom(void)
  2765. {
  2766.     int i;
  2767.     fprintf(stderr, "DMACON: %x INTENA: %x INTREQ: %x VPOS: %x HPOS: %x\n", DMACONR(),
  2768.        intena, intreq, vpos, current_hpos());
  2769.     if (timeframes) { 
  2770.     fprintf(stderr, "Average frame time: %d ms [frames: %d time: %d]\n", 
  2771.            frametime/timeframes, timeframes, frametime);
  2772.     }
  2773.     /*for (i=0; i<256; i++) if (blitcount[i]) fprintf(stderr, "minterm %x = %d\n",i,blitcount[i]);  blitter debug */
  2774. }
  2775.  
  2776. int intlev(void)
  2777. {
  2778.     UWORD imask = intreq & intena;
  2779.     if (imask && (intena & 0x4000)){
  2780.     if (imask & 0x2000) return 6;
  2781.     if (imask & 0x1800) return 5;
  2782.     if (imask & 0x0780) return 4;
  2783.     if (imask & 0x0070) return 3;
  2784.     if (imask & 0x0008) return 2;
  2785.     if (imask & 0x0007) return 1;
  2786.     }
  2787.     return -1;
  2788. }
  2789.  
  2790. void custom_init(void)
  2791. {
  2792.     int num;
  2793.     if (needmousehack())
  2794.     setfollow();
  2795.     customreset();
  2796.     for (num = 0; num < 256; num++) {    
  2797.     int plane1 = (num & 1) | ((num >> 1) & 2) | ((num >> 2) & 4) | ((num >> 3) & 8);
  2798.     int plane2 = ((num >> 1) & 1) | ((num >> 2) & 2) | ((num >> 3) & 4) | ((num >> 4) & 8);
  2799.     dblpf_2nd1[num] = plane1 == 0 ? (plane2 == 0 ? 0 : 2) : 1;
  2800.     dblpf_2nd2[num] = plane2 == 0 ? (plane1 == 0 ? 0 : 1) : 2;
  2801.     dblpf_aga1[num] = plane1 == 0 ? plane2 : plane1;
  2802.     dblpf_aga2[num] = plane2 == 0 ? plane1 : plane2;
  2803.     if (plane2 > 0) plane2 += 8;
  2804.     dblpf_ind1[num] = plane1 == 0 ? plane2 : plane1;
  2805.     dblpf_ind2[num] = plane2 == 0 ? plane1 : plane2;
  2806.     
  2807.     lots_of_twos[num] = num == 0 ? 0 : 2;
  2808.     linear_map_256[num] = num;
  2809.     }
  2810.     build_blitfilltable();
  2811.     gen_pfield_tables();
  2812. }
  2813.  
  2814. /* Custom chip memory bank */
  2815.  
  2816. static ULONG custom_lget(CPTR) REGPARAM;
  2817. static UWORD custom_wget(CPTR) REGPARAM;
  2818. static UBYTE custom_bget(CPTR) REGPARAM;
  2819. static void  custom_lput(CPTR, ULONG) REGPARAM;
  2820. static void  custom_wput(CPTR, UWORD) REGPARAM;
  2821. static void  custom_bput(CPTR, UBYTE) REGPARAM;
  2822.  
  2823. addrbank custom_bank = {
  2824.     default_alget, default_awget,
  2825.     custom_lget, custom_wget, custom_bget,
  2826.     custom_lput, custom_wput, custom_bput,
  2827.     default_xlate, default_check
  2828. };
  2829.  
  2830. UWORD custom_wget(CPTR addr)
  2831. {
  2832.     switch(addr & 0x1FE) {
  2833.      case 0x002: return DMACONR();
  2834.      case 0x004: return VPOSR();
  2835.      case 0x006: return VHPOSR();
  2836.     
  2837.      case 0x008: return DSKDATR();
  2838.  
  2839.      case 0x00A: return JOY0DAT();
  2840.      case 0x00C: return JOY1DAT();
  2841.      case 0x010: return ADKCONR();
  2842.  
  2843.      case 0x012: return POT0DAT();
  2844.      case 0x016: return POTGOR();
  2845.      case 0x018: return SERDATR();
  2846.      case 0x01A: return DSKBYTR();
  2847.      case 0x01C: return INTENAR();
  2848.      case 0x01E: return INTREQR();
  2849.  
  2850. #if AGA_CHIPSET == 1
  2851.      case 0x07C: return 0xF8;
  2852. #elif defined ECS_DENISE
  2853.      case 0x07C: return 0xFC;
  2854. #endif
  2855.      default:
  2856.     custom_wput(addr,0);
  2857.     return 0xffff;
  2858.     }
  2859. }
  2860.  
  2861. UBYTE custom_bget(CPTR addr)
  2862. {
  2863.     return custom_wget(addr & 0xfffe) >> (addr & 1 ? 0 : 8);
  2864. }
  2865.  
  2866. ULONG custom_lget(CPTR addr)
  2867. {
  2868.     return ((ULONG)custom_wget(addr & 0xfffe) << 16) | custom_wget((addr+2) & 0xfffe);
  2869. }
  2870.  
  2871. void custom_wput(CPTR addr, UWORD value)
  2872. {
  2873.     addr &= 0x1FE;
  2874.     cregs[addr>>1] = value;
  2875.     switch(addr) {    
  2876.      case 0x020: DSKPTH(value); break;
  2877.      case 0x022: DSKPTL(value); break;
  2878.      case 0x024: DSKLEN(value); break;
  2879.      case 0x026: DSKDAT(value); break;
  2880.     
  2881.      case 0x02A: VPOSW(value); break;
  2882.  
  2883.      case 0x030: SERDAT(value); break;
  2884.      case 0x032: SERPER(value); break;
  2885.  
  2886.      case 0x040: BLTCON0(value); break;
  2887.      case 0x042: BLTCON1(value); break;
  2888.     
  2889.      case 0x044: BLTAFWM(value); break;
  2890.      case 0x046: BLTALWM(value); break;
  2891.     
  2892.      case 0x050: BLTAPTH(value); break;
  2893.      case 0x052: BLTAPTL(value); break;
  2894.      case 0x04C: BLTBPTH(value); break;
  2895.      case 0x04E: BLTBPTL(value); break;
  2896.      case 0x048: BLTCPTH(value); break;
  2897.      case 0x04A: BLTCPTL(value); break;
  2898.      case 0x054: BLTDPTH(value); break;
  2899.      case 0x056: BLTDPTL(value); break;
  2900.     
  2901.      case 0x058: BLTSIZE(value); break;
  2902.     
  2903.      case 0x064: BLTAMOD(value); break;
  2904.      case 0x062: BLTBMOD(value); break;
  2905.      case 0x060: BLTCMOD(value); break;
  2906.      case 0x066: BLTDMOD(value); break;
  2907.     
  2908.      case 0x070: BLTCDAT(value); break;
  2909.      case 0x072: BLTBDAT(value); break;
  2910.      case 0x074: BLTADAT(value); break;
  2911.             
  2912.      case 0x07E: DSKSYNC(value); break;
  2913.  
  2914.      case 0x080: COP1LCH(value); break;
  2915.      case 0x082: COP1LCL(value); break;
  2916.      case 0x084: COP2LCH(value); break;
  2917.      case 0x086: COP2LCL(value); break;
  2918.     
  2919.      case 0x088: COPJMP1(value); break;
  2920.      case 0x08A: COPJMP2(value); break;
  2921.     
  2922.      case 0x08E: DIWSTRT(value); break;
  2923.      case 0x090: DIWSTOP(value); break;
  2924.      case 0x092: DDFSTRT(value); break;
  2925.      case 0x094: DDFSTOP(value); break;
  2926.     
  2927.      case 0x096: DMACON(value); break;
  2928.      case 0x09A: INTENA(value); break;
  2929.      case 0x09C: INTREQ(value); break;
  2930.      case 0x09E: ADKCON(value); break;
  2931.     
  2932.      case 0x0A0: AUDxLCH(0, value); break;
  2933.      case 0x0A2: AUDxLCL(0, value); break;
  2934.      case 0x0A4: AUDxLEN(0, value); break;
  2935.      case 0x0A6: AUDxPER(0, value); break;
  2936.      case 0x0A8: AUDxVOL(0, value); break;
  2937.      case 0x0AA: AUDxDAT(0, value); break;
  2938.     
  2939.      case 0x0B0: AUDxLCH(1, value); break;
  2940.      case 0x0B2: AUDxLCL(1, value); break;
  2941.      case 0x0B4: AUDxLEN(1, value); break;
  2942.      case 0x0B6: AUDxPER(1, value); break;
  2943.      case 0x0B8: AUDxVOL(1, value); break;
  2944.      case 0x0BA: AUDxDAT(1, value); break;
  2945.     
  2946.      case 0x0C0: AUDxLCH(2, value); break;
  2947.      case 0x0C2: AUDxLCL(2, value); break;
  2948.      case 0x0C4: AUDxLEN(2, value); break;
  2949.      case 0x0C6: AUDxPER(2, value); break;
  2950.      case 0x0C8: AUDxVOL(2, value); break;
  2951.      case 0x0CA: AUDxDAT(2, value); break;
  2952.     
  2953.      case 0x0D0: AUDxLCH(3, value); break;
  2954.      case 0x0D2: AUDxLCL(3, value); break;
  2955.      case 0x0D4: AUDxLEN(3, value); break;
  2956.      case 0x0D6: AUDxPER(3, value); break;
  2957.      case 0x0D8: AUDxVOL(3, value); break;
  2958.      case 0x0DA: AUDxDAT(3, value); break;
  2959.     
  2960.      case 0x0E0: BPLPTH(value, 0); break;
  2961.      case 0x0E2: BPLPTL(value, 0); break;
  2962.      case 0x0E4: BPLPTH(value, 1); break;
  2963.      case 0x0E6: BPLPTL(value, 1); break;
  2964.      case 0x0E8: BPLPTH(value, 2); break;
  2965.      case 0x0EA: BPLPTL(value, 2); break;
  2966.      case 0x0EC: BPLPTH(value, 3); break;
  2967.      case 0x0EE: BPLPTL(value, 3); break;
  2968.      case 0x0F0: BPLPTH(value, 4); break;
  2969.      case 0x0F2: BPLPTL(value, 4); break;
  2970.      case 0x0F4: BPLPTH(value, 5); break;
  2971.      case 0x0F6: BPLPTL(value, 5); break;
  2972.     
  2973.      case 0x100: BPLCON0(value); break;
  2974.      case 0x102: BPLCON1(value); break;
  2975.      case 0x104: BPLCON2(value); break;
  2976.      case 0x106: BPLCON3(value); break;
  2977.     
  2978.      case 0x108: BPL1MOD(value); break;
  2979.      case 0x10A: BPL2MOD(value); break;
  2980.  
  2981.      case 0x110: BPL1DAT(value); break;
  2982.      case 0x112: BPL2DAT(value); break;
  2983.      case 0x114: BPL3DAT(value); break;
  2984.      case 0x116: BPL4DAT(value); break;
  2985.      case 0x118: BPL5DAT(value); break;
  2986.      case 0x11A: BPL6DAT(value); break;
  2987.     
  2988.      case 0x180: case 0x182: case 0x184: case 0x186: case 0x188: case 0x18A:
  2989.      case 0x18C: case 0x18E: case 0x190: case 0x192: case 0x194: case 0x196:
  2990.      case 0x198: case 0x19A: case 0x19C: case 0x19E: case 0x1A0: case 0x1A2:
  2991.      case 0x1A4: case 0x1A6: case 0x1A8: case 0x1AA: case 0x1AC: case 0x1AE:
  2992.      case 0x1B0: case 0x1B2: case 0x1B4: case 0x1B6: case 0x1B8: case 0x1BA:
  2993.      case 0x1BC: case 0x1BE: 
  2994.     COLOR(value & 0xFFF, (addr & 0x3E) / 2);
  2995.     break;    
  2996.      case 0x120: case 0x124: case 0x128: case 0x12C: 
  2997.      case 0x130: case 0x134: case 0x138: case 0x13C:
  2998.     SPRxPTH(value, (addr - 0x120) / 4);
  2999.     break;
  3000.      case 0x122: case 0x126: case 0x12A: case 0x12E: 
  3001.      case 0x132: case 0x136: case 0x13A: case 0x13E:
  3002.     SPRxPTL(value, (addr - 0x122) / 4);
  3003.     break;
  3004.      case 0x140: case 0x148: case 0x150: case 0x158: 
  3005.      case 0x160: case 0x168: case 0x170: case 0x178:
  3006.     SPRxPOS(value, (addr - 0x140) / 8);
  3007.     break;
  3008.      case 0x142: case 0x14A: case 0x152: case 0x15A: 
  3009.      case 0x162: case 0x16A: case 0x172: case 0x17A:
  3010.     SPRxCTL(value, (addr - 0x142) / 8);
  3011.     break;
  3012.      case 0x144: case 0x14C: case 0x154: case 0x15C:
  3013.      case 0x164: case 0x16C: case 0x174: case 0x17C:
  3014.     SPRxDATA(value, (addr - 0x144) / 8);
  3015.     break;
  3016.      case 0x146: case 0x14E: case 0x156: case 0x15E: 
  3017.      case 0x166: case 0x16E: case 0x176: case 0x17E:
  3018.     SPRxDATB(value, (addr - 0x146) / 8);
  3019.     break;
  3020.     
  3021.      case 0x36: JOYTEST(value); break;
  3022. #if defined(ECS_AGNUS) || (AGA_CHIPSET == 1)
  3023.      case 0x5A: BLTCON0L(value); break;
  3024.      case 0x5C: BLTSIZV(value); break;
  3025.      case 0x5E: BLTSIZH(value); break;
  3026. #endif
  3027. #if AGA_CHIPSET == 1
  3028.      case 0x10C: BPLCON4(value); break;
  3029.      case 0x1FC: fmode = value; break;
  3030. #endif
  3031.     }
  3032. }
  3033.  
  3034. void custom_bput(CPTR addr, UBYTE value)
  3035. {
  3036.     /* Yes, there are programs that do this. The programmers should be shot.
  3037.      * This might actually work sometimes. */
  3038.     UWORD rval = value;
  3039.     CPTR raddr = addr & 0x1FE;
  3040.     if (addr & 1) {
  3041.     rval |= cregs[raddr >> 1] & 0xFF00;
  3042.     } else {
  3043.     rval <<= 8;
  3044.     rval |= cregs[raddr >> 1] & 0xFF;
  3045.     }
  3046.     custom_wput(raddr, rval);
  3047. }
  3048.  
  3049. void custom_lput(CPTR addr, ULONG value)
  3050. {
  3051.     custom_wput(addr & 0xfffe, value >> 16);
  3052.     custom_wput((addr+2) & 0xfffe, (UWORD)value);
  3053. }
  3054.  
  3055.